From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on dcvr.yhbt.net X-Spam-Level: X-Spam-ASN: X-Spam-Status: No, score=-3.8 required=3.0 tests=ALL_TRUSTED,AWL,BAYES_00 shortcircuit=no autolearn=ham autolearn_force=no version=3.4.2 Received: from localhost (dcvr.yhbt.net [127.0.0.1]) by dcvr.yhbt.net (Postfix) with ESMTP id B7100211B9 for ; Sat, 1 Dec 2018 13:31:27 +0000 (UTC) From: Eric Wong To: kcar-public@bogomips.org Subject: [PATCH 06/11] filter_body: rename variables to be like memcpy(3) Date: Sat, 1 Dec 2018 13:31:20 +0000 Message-Id: <20181201133125.5524-7-e@80x24.org> In-Reply-To: <20181201133125.5524-1-e@80x24.org> References: <20181201133125.5524-1-e@80x24.org> List-Id: 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)