From mboxrd@z Thu Jan 1 00:00:00 1970 Path: news.gmane.org!not-for-mail From: "Neil Jerram" Newsgroups: gmane.lisp.guile.devel Subject: Re: [PATCH] Add a `read' method for ports Date: Tue, 15 Jul 2008 23:08:01 +0100 Message-ID: <49dd78620807151507t2a0d90cna48f64f86a38fe2b@mail.gmail.com> References: <87hccdgexp.fsf@gnu.org> <871w374p5p.fsf@gnu.org> <49dd78620806091001p468a7e8bt2a0d9bbb2061b61@mail.gmail.com> <87wskyuxxa.fsf@gnu.org> <49dd78620806111438v26ef5ba2t7ec7d8b2c858cf@mail.gmail.com> <87y75bcceo.fsf@gnu.org> <49dd78620806121718o3cb1ae2dta673ef86cee79382@mail.gmail.com> <87tzfi8smz.fsf@gnu.org> NNTP-Posting-Host: lo.gmane.org Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="----=_Part_12619_26401377.1216159681426" X-Trace: ger.gmane.org 1216159733 14103 80.91.229.12 (15 Jul 2008 22:08:53 GMT) X-Complaints-To: usenet@ger.gmane.org NNTP-Posting-Date: Tue, 15 Jul 2008 22:08:53 +0000 (UTC) Cc: guile-devel@gnu.org To: "=?ISO-8859-1?Q?Ludovic_Court=E8s?=" Original-X-From: guile-devel-bounces+guile-devel=m.gmane.org@gnu.org Wed Jul 16 00:09:39 2008 Return-path: Envelope-to: guile-devel@m.gmane.org Original-Received: from lists.gnu.org ([199.232.76.165]) by lo.gmane.org with esmtp (Exim 4.50) id 1KIsiF-00013T-6k for guile-devel@m.gmane.org; Wed, 16 Jul 2008 00:09:35 +0200 Original-Received: from localhost ([127.0.0.1]:53807 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1KIshM-0004Fy-Ma for guile-devel@m.gmane.org; Tue, 15 Jul 2008 18:08:40 -0400 Original-Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1KIsgp-0003fY-G6 for guile-devel@gnu.org; Tue, 15 Jul 2008 18:08:07 -0400 Original-Received: from exim by lists.gnu.org with spam-scanned (Exim 4.43) id 1KIsgm-0003cG-NP for guile-devel@gnu.org; Tue, 15 Jul 2008 18:08:06 -0400 Original-Received: from [199.232.76.173] (port=55556 helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1KIsgm-0003c0-Aq for guile-devel@gnu.org; Tue, 15 Jul 2008 18:08:04 -0400 Original-Received: from wa-out-1112.google.com ([209.85.146.177]:47472) by monty-python.gnu.org with esmtp (Exim 4.60) (envelope-from ) id 1KIsgk-0006Eo-Vj for guile-devel@gnu.org; Tue, 15 Jul 2008 18:08:04 -0400 Original-Received: by wa-out-1112.google.com with SMTP id m34so3162043wag.10 for ; Tue, 15 Jul 2008 15:08:01 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=googlemail.com; s=gamma; h=domainkey-signature:received:received:message-id:date:from:to :subject:cc:in-reply-to:mime-version:content-type:references; bh=uVneFG8fLhEvgmLAJ6NYUx4fmgTpN1ZvIN3WSRj+G+Y=; b=eDfy8+otj4tg+goDOrk+Vh4298Rt8WpnKCzRkty0xSFDMma0aZFo+bO/vwkgZYUbIC h/IKF1yh3KaUAWFjU30pRviGv6tfYr9F6ZF8HtenXqH1D7CMa4zZlirTnknabxn1MZ98 85ghw5Gflhy8ltLKF2r83Bg4SGtMnIjSbtDX8= DomainKey-Signature: a=rsa-sha1; c=nofws; d=googlemail.com; s=gamma; h=message-id:date:from:to:subject:cc:in-reply-to:mime-version :content-type:references; b=cyWHiuNDjdWkdRs/E0dAk9CoX2fu9Q1/UiYSxtMsL8SQ8iTrkUDgXJeChgUqwky01I jNE0FjMriMr0QAHLuvT0Fkkq8mQy0rTRLzt5hvgFsUxj3HgG8bWBvYje8YLGqh3kjeKe G5JePSKSRKm2Qwq/xvAsPAlPcaxIjQzvBq8zM= Original-Received: by 10.114.168.1 with SMTP id q1mr644383wae.72.1216159681592; Tue, 15 Jul 2008 15:08:01 -0700 (PDT) Original-Received: by 10.114.197.8 with HTTP; Tue, 15 Jul 2008 15:08:01 -0700 (PDT) In-Reply-To: <87tzfi8smz.fsf@gnu.org> X-detected-kernel: by monty-python.gnu.org: Linux 2.6 (newer, 2) X-BeenThere: guile-devel@gnu.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: "Developers list for Guile, the GNU extensibility library" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Original-Sender: guile-devel-bounces+guile-devel=m.gmane.org@gnu.org Errors-To: guile-devel-bounces+guile-devel=m.gmane.org@gnu.org Xref: news.gmane.org gmane.lisp.guile.devel:7384 Archived-At: ------=_Part_12619_26401377.1216159681426 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Content-Disposition: inline 2008/6/24 Ludovic Court=E8s : > Hi Neil, > > Sorry for the delay, I was off-line last week. No problem! > "Neil Jerram" writes: > >> Agreed. Yesterday I was worried about possible confusion from >> bypassing a port's read buffer at a time when the read buffer has some >> data in it. But in fact this is not a problem, because >> scm_fill_input() should be (and in practice is) only called when the >> port's read buffer is empty. > > Right. Putting an assertion in there to make sure can't hurt. OK, done. > These arguments make a lot of sense in 1.8. In the longer run, though, > I'd prefer to see `fill_input' superseded by a `read' method akin to > what I proposed. What do you think? To be honest, I don't yet see a clear need for it. If there is no drawback to what we have now, and there would be a compatibility cost to introducing a new read method, then why do that? >> Based on all this, I'd like to update my suggestion so that >> >> - scm_fill_input_buf always uses the caller's buffer >> >> - the remaining scm_fill_input_buf logic is inlined into scm_c_read >> (since that is the only place that uses scm_fill_input_buf, and >> inlining it permits some further simplifications). > > OK. The issue is that if the caller-supplied buffer is smaller than the > port's buffer, we end up reading less data than we'd otherwise do. I > think this scenario should be addressed (by comparing `read_buf_size' > and `size'), as was the case in my proposal. True in theory, but I feel very confident that this will never matter in practice, and hence that we don't need to have code for this. Confidence is based on experience from my day job, which is in network protocols - where buffered reads are a very common operation. On the other hand, it is possible I've missed some other application where different patterns/rules apply, so please let me know if you have specific counterexamples in mind. >> + /* Now we will call scm_fill_input repeatedly until we have read the >> + requested number of bytes. (Note that a single scm_fill_input >> + call does not guarantee to fill the whole of the port's read >> + buffer.) For these calls, since we already have a buffer here to >> + read into, we bypass the port's own read buffer (if it has one), >> + by saving it off and modifying the port structure to point to our >> + own buffer. */ >> + saved_buf =3D pt->read_buf; >> + saved_buf_size =3D pt->read_buf_size; >> + pt->read_pos =3D pt->read_buf =3D pt->read_end =3D buffer; >> + pt->read_buf_size =3D size; > > `fill_input' methods can raise an exception, as is the case with soft > parts. Thus, this code should be protected by a `dynwind' that > restores the port's buffer and size. Good point. I've added this. >> + remaining -=3D scm_c_read (port_or_fd, base + off, remaining); >> + if (remaining % sz !=3D 0) >> + SCM_MISC_ERROR ("unexpected EOF", SCM_EOL); >> + ans -=3D remaining / sz; > > Likewise, `scm_c_read ()' might raise an exception, so we may need a > `dynwind' here (my original patch for `uniform-vector-read!' did that). This is covered by the dynwind inside scm_c_read, isn't it? Updated patch is attached. As well as taking a look, could you check that it really improves performance in the cases that motivated this? I tried running the read.bm benchmarks, but in those cases it didn't seem to make much difference; is that expected? Regards, Neil ------=_Part_12619_26401377.1216159681426 Content-Type: text/x-patch; name=unbuffered-read.diff Content-Transfer-Encoding: base64 X-Attachment-Id: f_fip20xma0 Content-Disposition: attachment; filename=unbuffered-read.diff ZGlmZiAtLWdpdCBhL2xpYmd1aWxlL0NoYW5nZUxvZyBiL2xpYmd1aWxlL0NoYW5nZUxvZwppbmRl eCA1YzMwNTc0Li5kMWJmMGQ5IDEwMDY0NAotLS0gYS9saWJndWlsZS9DaGFuZ2VMb2cKKysrIGIv bGliZ3VpbGUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMDgtMDctMTUgIE5laWwgSmVy cmFtICA8bmVpbEBvc3NhdS51a2xpbnV4Lm5ldD4KKworCSogc3JmaS00LmMgKHNjbV91bmlmb3Jt X3ZlY3Rvcl9yZWFkX3gpOiBVc2Ugc2NtX2NfcmVhZCwgaW5zdGVhZCBvZgorCWVxdWl2YWxlbnQg Y29kZSBoZXJlLgorCisJKiBwb3J0cy5jIChzY21fZmlsbF9pbnB1dCk6IEFkZCBhc3NlcnRpb24g dGhhdCByZWFkIGJ1ZmZlciBpcworCWVtcHR5IHdoZW4gY2FsbGVkLgorCShwb3J0X2FuZF9zd2Fw X2J1ZmZlciwgc3dhcF9idWZmZXIpOiBOZXcsIGZvci4uLgorCShzY21fY19yZWFkKTogVXNlIGNh bGxlcidzIGJ1ZmZlciBmb3IgcmVhZGluZywgdG8gYXZvaWQgbWFraW5nIE4KKwkxLWJ5dGUgbG93 LWxldmVsIHJlYWQgY2FsbHMsIGluIHRoZSBjYXNlIHdoZXJlIHRoZSBwb3J0IGlzCisJdW5idWZm ZXJlZCAob3IgaGFzIGEgdmVyeSBzbWFsbCBidWZmZXIpLgorCiAyMDA4LTA3LTA1ICBMdWRvdmlj IENvdXJ0w6hzICA8bHVkb0BnbnUub3JnPgogCiAJKiBzdHJpbmdzLmMgKHNjbV9jX3N5bWJvbF9s ZW5ndGgpOiBOZXcgZnVuY3Rpb24uCmRpZmYgLS1naXQgYS9saWJndWlsZS9wb3J0cy5jIGIvbGli Z3VpbGUvcG9ydHMuYwppbmRleCBiOTdjODI2Li45NTYzMDAxIDEwMDY0NAotLS0gYS9saWJndWls ZS9wb3J0cy5jCisrKyBiL2xpYmd1aWxlL3BvcnRzLmMKQEAgLTI4LDYgKzI4LDcgQEAKICNpbmNs dWRlIDxzdGRpby5oPgogI2luY2x1ZGUgPGVycm5vLmg+CiAjaW5jbHVkZSA8ZmNudGwuaD4gIC8q IGZvciBjaHNpemUgb24gbWluZ3cgKi8KKyNpbmNsdWRlIDxhc3NlcnQuaD4KIAogI2luY2x1ZGUg ImxpYmd1aWxlL19zY20uaCIKICNpbmNsdWRlICJsaWJndWlsZS9hc3luYy5oIgpAQCAtOTc0LDYg Kzk3NSw4IEBAIHNjbV9maWxsX2lucHV0IChTQ00gcG9ydCkKIHsKICAgc2NtX3RfcG9ydCAqcHQg PSBTQ01fUFRBQl9FTlRSWSAocG9ydCk7CiAKKyAgYXNzZXJ0IChwdC0+cmVhZF9wb3MgPT0gcHQt PnJlYWRfZW5kKTsKKwogICBpZiAocHQtPnJlYWRfYnVmID09IHB0LT5wdXRiYWNrX2J1ZikKICAg ICB7CiAgICAgICAvKiBmaW5pc2hlZCByZWFkaW5nIHB1dC1iYWNrIGNoYXJzLiAgKi8KQEAgLTEw MzYsMTIgKzEwMzksMzUgQEAgc2NtX2xmd3JpdGUgKGNvbnN0IGNoYXIgKnB0ciwgc2l6ZV90IHNp emUsIFNDTSBwb3J0KQogICoKICAqIFdhcm5pbmc6IERvZXNuJ3QgdXBkYXRlIHBvcnQgbGluZSBh bmQgY29sdW1uIGNvdW50cyEgICovCiAKK3N0cnVjdCBwb3J0X2FuZF9zd2FwX2J1ZmZlciB7Cisg IHNjbV90X3BvcnQgKnB0OworICB1bnNpZ25lZCBjaGFyICpidWZmZXI7CisgIHNpemVfdCBzaXpl OworfTsKKworc3RhdGljIHZvaWQKK3N3YXBfYnVmZmVyICh2b2lkICpkYXRhKQoreworICBzdHJ1 Y3QgcG9ydF9hbmRfc3dhcF9idWZmZXIgKnBzYiA9IChzdHJ1Y3QgcG9ydF9hbmRfc3dhcF9idWZm ZXIgKikgZGF0YTsKKyAgdW5zaWduZWQgY2hhciAqb2xkX2J1ZiA9IHBzYi0+cHQtPnJlYWRfYnVm OworICBzaXplX3Qgb2xkX3NpemUgPSBwc2ItPnB0LT5yZWFkX2J1Zl9zaXplOworCisgIC8qIE1h a2UgdGhlIHBvcnQgdXNlIChidWZmZXIsIHNpemUpIGZyb20gdGhlIHN0cnVjdC4gKi8KKyAgcHNi LT5wdC0+cmVhZF9wb3MgPSBwc2ItPnB0LT5yZWFkX2J1ZiA9IHBzYi0+cHQtPnJlYWRfZW5kID0g cHNiLT5idWZmZXI7CisgIHBzYi0+cHQtPnJlYWRfYnVmX3NpemUgPSBwc2ItPnNpemU7CisKKyAg LyogU2F2ZSB0aGUgcG9ydCdzIG9sZCAoYnVmZmVyLCBzaXplKSBpbiB0aGUgc3RydWN0LiAqLwor ICBwc2ItPmJ1ZmZlciA9IG9sZF9idWY7CisgIHBzYi0+c2l6ZSA9IG9sZF9zaXplOworfQorCiBz aXplX3QKIHNjbV9jX3JlYWQgKFNDTSBwb3J0LCB2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKQog I2RlZmluZSBGVU5DX05BTUUgInNjbV9jX3JlYWQiCiB7CiAgIHNjbV90X3BvcnQgKnB0OwogICBz aXplX3Qgbl9yZWFkID0gMCwgbl9hdmFpbGFibGU7CisgIHN0cnVjdCBwb3J0X2FuZF9zd2FwX2J1 ZmZlciBwc2I7CiAKICAgU0NNX1ZBTElEQVRFX09QSU5QT1JUICgxLCBwb3J0KTsKIApAQCAtMTA1 MiwzNSArMTA3OCw0OCBAQCBzY21fY19yZWFkIChTQ00gcG9ydCwgdm9pZCAqYnVmZmVyLCBzaXpl X3Qgc2l6ZSkKICAgaWYgKHB0LT5yd19yYW5kb20pCiAgICAgcHQtPnJ3X2FjdGl2ZSA9IFNDTV9Q T1JUX1JFQUQ7CiAKLSAgaWYgKFNDTV9SRUFEX0JVRkZFUl9FTVBUWV9QIChwdCkpCi0gICAgewot ICAgICAgaWYgKHNjbV9maWxsX2lucHV0IChwb3J0KSA9PSBFT0YpCi0JcmV0dXJuIDA7Ci0gICAg fQotICAKLSAgbl9hdmFpbGFibGUgPSBwdC0+cmVhZF9lbmQgLSBwdC0+cmVhZF9wb3M7Ci0gIAot ICB3aGlsZSAobl9hdmFpbGFibGUgPCBzaXplKQorICAvKiBUYWtlIGJ5dGVzIGZpcnN0IGZyb20g dGhlIHBvcnQncyByZWFkIGJ1ZmZlci4gKi8KKyAgaWYgKHB0LT5yZWFkX3BvcyA8IHB0LT5yZWFk X2VuZCkKICAgICB7CisgICAgICBuX2F2YWlsYWJsZSA9IG1pbiAoc2l6ZSwgcHQtPnJlYWRfZW5k IC0gcHQtPnJlYWRfcG9zKTsKICAgICAgIG1lbWNweSAoYnVmZmVyLCBwdC0+cmVhZF9wb3MsIG5f YXZhaWxhYmxlKTsKICAgICAgIGJ1ZmZlciA9IChjaGFyICopIGJ1ZmZlciArIG5fYXZhaWxhYmxl OwogICAgICAgcHQtPnJlYWRfcG9zICs9IG5fYXZhaWxhYmxlOwogICAgICAgbl9yZWFkICs9IG5f YXZhaWxhYmxlOwotICAgICAgCi0gICAgICBpZiAoU0NNX1JFQURfQlVGRkVSX0VNUFRZX1AgKHB0 KSkKLQl7Ci0JICBpZiAoc2NtX2ZpbGxfaW5wdXQgKHBvcnQpID09IEVPRikKLQkgICAgcmV0dXJu IG5fcmVhZDsKLQl9Ci0KICAgICAgIHNpemUgLT0gbl9hdmFpbGFibGU7Ci0gICAgICBuX2F2YWls YWJsZSA9IHB0LT5yZWFkX2VuZCAtIHB0LT5yZWFkX3BvczsKICAgICB9CiAKLSAgbWVtY3B5IChi dWZmZXIsIHB0LT5yZWFkX3Bvcywgc2l6ZSk7Ci0gIHB0LT5yZWFkX3BvcyArPSBzaXplOworICAv KiBOb3cgd2Ugd2lsbCBjYWxsIHNjbV9maWxsX2lucHV0IHJlcGVhdGVkbHkgdW50aWwgd2UgaGF2 ZSByZWFkIHRoZQorICAgICByZXF1ZXN0ZWQgbnVtYmVyIG9mIGJ5dGVzLiAgKE5vdGUgdGhhdCBh IHNpbmdsZSBzY21fZmlsbF9pbnB1dAorICAgICBjYWxsIGRvZXMgbm90IGd1YXJhbnRlZSB0byBm aWxsIHRoZSB3aG9sZSBvZiB0aGUgcG9ydCdzIHJlYWQKKyAgICAgYnVmZmVyLikgIEZvciB0aGVz ZSBjYWxscywgc2luY2Ugd2UgYWxyZWFkeSBoYXZlIGEgYnVmZmVyIGhlcmUgdG8KKyAgICAgcmVh ZCBpbnRvLCB3ZSBieXBhc3MgdGhlIHBvcnQncyBvd24gcmVhZCBidWZmZXIgKGlmIGl0IGhhcyBv bmUpLAorICAgICBieSBzYXZpbmcgaXQgb2ZmIGFuZCBtb2RpZnlpbmcgdGhlIHBvcnQgc3RydWN0 dXJlIHRvIHBvaW50IHRvIG91cgorICAgICBvd24gYnVmZmVyLgorCisgICAgIFdlIG5lZWQgdG8g bWFrZSBzdXJlIHRoYXQgdGhlIHBvcnQncyBub3JtYWwgYnVmZmVyIGlzIHJlaW5zdGF0ZWQKKyAg ICAgaW4gY2FzZSBvbmUgb2YgdGhlIHNjbV9maWxsX2lucHV0ICgpIGNhbGxzIHRocm93cyBhbiBl eGNlcHRpb247CisgICAgIHdlIHVzZSB0aGUgc2NtX2R5bndpbmRfKiBBUEkgdG8gYWNoaWV2ZSB0 aGF0LiAqLworICBwc2IucHQgPSBwdDsKKyAgcHNiLmJ1ZmZlciA9IGJ1ZmZlcjsKKyAgcHNiLnNp emUgPSBzaXplOworICBzY21fZHlud2luZF9iZWdpbiAoU0NNX0ZfRFlOV0lORF9SRVdJTkRBQkxF KTsKKyAgc2NtX2R5bndpbmRfcmV3aW5kX2hhbmRsZXIgKHN3YXBfYnVmZmVyLCAmcHNiLCBTQ01f Rl9XSU5EX0VYUExJQ0lUTFkpOworICBzY21fZHlud2luZF91bndpbmRfaGFuZGxlciAoc3dhcF9i dWZmZXIsICZwc2IsIFNDTV9GX1dJTkRfRVhQTElDSVRMWSk7CisKKyAgLyogQ2FsbCBzY21fZmls bF9pbnB1dCB1bnRpbCB3ZSBoYXZlIGFsbCB0aGUgYnl0ZXMgdGhhdCB3ZSBuZWVkLCBvcgorICAg ICB3ZSBoaXQgRU9GLiAqLworICB3aGlsZSAocHQtPnJlYWRfYnVmX3NpemUgJiYgKHNjbV9maWxs X2lucHV0IChwb3J0KSAhPSBFT0YpKQorICAgIHsKKyAgICAgIHB0LT5yZWFkX2J1Zl9zaXplIC09 IChwdC0+cmVhZF9lbmQgLSBwdC0+cmVhZF9wb3MpOworICAgICAgcHQtPnJlYWRfcG9zID0gcHQt PnJlYWRfYnVmID0gcHQtPnJlYWRfZW5kOworICAgIH0KKyAgbl9yZWFkICs9IHB0LT5yZWFkX2J1 ZiAtICh1bnNpZ25lZCBjaGFyICopIGJ1ZmZlcjsKKworICAvKiBSZWluc3RhdGUgdGhlIHBvcnQn cyBub3JtYWwgYnVmZmVyLiAqLworICBzY21fZHlud2luZF9lbmQgKCk7CiAKLSAgcmV0dXJuIG5f cmVhZCArIHNpemU7CisgIHJldHVybiBuX3JlYWQ7CiB9CiAjdW5kZWYgRlVOQ19OQU1FCiAKZGlm ZiAtLWdpdCBhL2xpYmd1aWxlL3NyZmktNC5jIGIvbGliZ3VpbGUvc3JmaS00LmMKaW5kZXggN2Qy MmY4Yi4uYTAxZjg2ZSAxMDA2NDQKLS0tIGEvbGliZ3VpbGUvc3JmaS00LmMKKysrIGIvbGliZ3Vp bGUvc3JmaS00LmMKQEAgLTg4NiwzOCArODg2LDExIEBAIFNDTV9ERUZJTkUgKHNjbV91bmlmb3Jt X3ZlY3Rvcl9yZWFkX3gsICJ1bmlmb3JtLXZlY3Rvci1yZWFkISIsIDEsIDMsIDAsCiAKICAgaWYg KFNDTV9OSU1QIChwb3J0X29yX2ZkKSkKICAgICB7Ci0gICAgICBzY21fdF9wb3J0ICpwdCA9IFND TV9QVEFCX0VOVFJZIChwb3J0X29yX2ZkKTsKLQotICAgICAgaWYgKHB0LT5yd19hY3RpdmUgPT0g U0NNX1BPUlRfV1JJVEUpCi0Jc2NtX2ZsdXNoIChwb3J0X29yX2ZkKTsKLQogICAgICAgYW5zID0g Y2VuZCAtIGNzdGFydDsKLSAgICAgIHdoaWxlIChyZW1haW5pbmcgPiAwKQotCXsKLQkgIGlmIChw dC0+cmVhZF9wb3MgPCBwdC0+cmVhZF9lbmQpCi0JICAgIHsKLQkgICAgICBzaXplX3QgdG9fY29w eSA9IG1pbiAocHQtPnJlYWRfZW5kIC0gcHQtPnJlYWRfcG9zLAotCQkJCSAgICByZW1haW5pbmcp OwotCSAgICAgIAotCSAgICAgIG1lbWNweSAoYmFzZSArIG9mZiwgcHQtPnJlYWRfcG9zLCB0b19j b3B5KTsKLQkgICAgICBwdC0+cmVhZF9wb3MgKz0gdG9fY29weTsKLQkgICAgICByZW1haW5pbmcg LT0gdG9fY29weTsKLQkgICAgICBvZmYgKz0gdG9fY29weTsKLQkgICAgfQotCSAgZWxzZQotCSAg ICB7Ci0JICAgICAgaWYgKHNjbV9maWxsX2lucHV0IChwb3J0X29yX2ZkKSA9PSBFT0YpCi0JCXsK LQkJICBpZiAocmVtYWluaW5nICUgc3ogIT0gMCkKLQkJICAgIFNDTV9NSVNDX0VSUk9SICgidW5l eHBlY3RlZCBFT0YiLCBTQ01fRU9MKTsKLQkJICBhbnMgLT0gcmVtYWluaW5nIC8gc3o7Ci0JCSAg YnJlYWs7Ci0JCX0KLQkgICAgfQotCX0KLSAgICAgIAotICAgICAgaWYgKHB0LT5yd19yYW5kb20p Ci0JcHQtPnJ3X2FjdGl2ZSA9IFNDTV9QT1JUX1JFQUQ7CisgICAgICByZW1haW5pbmcgLT0gc2Nt X2NfcmVhZCAocG9ydF9vcl9mZCwgYmFzZSArIG9mZiwgcmVtYWluaW5nKTsKKyAgICAgIGlmIChy ZW1haW5pbmcgJSBzeiAhPSAwKQorICAgICAgICBTQ01fTUlTQ19FUlJPUiAoInVuZXhwZWN0ZWQg RU9GIiwgU0NNX0VPTCk7CisgICAgICBhbnMgLT0gcmVtYWluaW5nIC8gc3o7CiAgICAgfQogICBl bHNlIC8qIGZpbGUgZGVzY3JpcHRvci4gICovCiAgICAgewo= ------=_Part_12619_26401377.1216159681426--