[PATCH 06/11] filter_body: rename variables to be like memcpy(3)

[Eric Wong <e@80x24.org>]

This makes the naming more consistent with terminology used for
memcpy, since this method is intended to act like memcpy(3)

No actual functionality change.
---
 ext/kcar/kcar.rl | 46 +++++++++++++++++++++++-----------------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/ext/kcar/kcar.rl b/ext/kcar/kcar.rl
index 01e4c76..ea3dacc 100644
--- a/ext/kcar/kcar.rl
+++ b/ext/kcar/kcar.rl
@@ -988,55 +988,55 @@ static VALUE keepalive(VALUE self)
 
 /**
  * call-seq:
- *    parser.filter_body(buf, data) => nil/data
+ *    parser.filter_body(dst, src) => nil/dst
  *
- * Takes a String of +data+, will modify data if dechunking is done.
- * Returns +nil+ if there is more data left to process.  Returns
- * +data+ if body processing is complete. When returning +data+,
- * it may modify +data+ so the start of the string points to where
+ * Takes a String of +src+, will modify src if dechunking is done.
+ * Returns +nil+ if there is more +src+ left to process.  Returns
+ * +dst+ if body processing is complete. When returning +dst+,
+ * it may modify +src+ so the start of the string points to where
  * the body ended so that trailer processing can begin.
  *
  * Raises ParserError if there are dechunking errors.
- * Basically this is a glorified memcpy(3) that copies +data+
- * into +buf+ while filtering it through the dechunker.
+ * Basically this is a glorified memcpy(3) that copies +src+
+ * into +dst+ while filtering it through the dechunker.
  */
-static VALUE filter_body(VALUE self, VALUE buf, VALUE data)
+static VALUE filter_body(VALUE self, VALUE dst, VALUE src)
 {
   struct http_parser *hp = data_get(self);
-  char *dptr;
-  long dlen;
+  char *sptr;
+  long slen;
 
-  dptr = RSTRING_PTR(data);
-  dlen = RSTRING_LEN(data);
-  check_buffer_size(dlen);
+  sptr = RSTRING_PTR(src);
+  slen = RSTRING_LEN(src);
+  check_buffer_size(slen);
 
-  StringValue(buf);
-  rb_str_modify(buf);
-  rb_str_resize(buf, dlen); /* we can never copy more than dlen bytes */
-  OBJ_TAINT(buf); /* keep weirdo $SAFE users happy */
+  StringValue(dst);
+  rb_str_modify(dst);
+  rb_str_resize(dst, slen); /* we can never copy more than slen bytes */
+  OBJ_TAINT(dst); /* keep weirdo $SAFE users happy */
 
   if (!hp->chunked)
     rb_raise(rb_eRuntimeError, "filter_body is only for chunked bodies");
 
   if (!chunked_eof(hp)) {
     hp->s.dest_offset = 0;
-    http_parser_execute(hp, buf, dptr, dlen);
+    http_parser_execute(hp, dst, sptr, slen);
     if (hp->cs == http_parser_error)
       rb_raise(eParserError, "Invalid HTTP format, parsing fails.");
 
     assert(hp->s.dest_offset <= hp->offset &&
            "destination buffer overflow");
-    advance_str(data, hp->offset);
-    rb_str_set_len(buf, hp->s.dest_offset);
+    advance_str(src, hp->offset);
+    rb_str_set_len(dst, hp->s.dest_offset);
 
-    if (RSTRING_LEN(buf) == 0 && chunked_eof(hp)) {
+    if (RSTRING_LEN(dst) == 0 && chunked_eof(hp)) {
       assert(hp->len.chunk == 0 && "chunk at EOF but more to parse");
     } else {
-      data = Qnil;
+      dst = Qnil;
     }
   }
   hp->offset = 0; /* for trailer parsing */
-  return data;
+  return dst;
 }
 
 void Init_kcar_ext(void)