From debbugs-submit-bounces@debbugs.gnu.org Wed Sep 11 18:04:20 2024 Received: (at submit) by debbugs.gnu.org; 11 Sep 2024 22:04:20 +0000 Received: from localhost ([127.0.0.1]:39692 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1soVRi-0003t6-Uf for submit@debbugs.gnu.org; Wed, 11 Sep 2024 18:04:20 -0400 Received: from lists.gnu.org ([209.51.188.17]:39790) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1soVRf-0003sx-79 for submit@debbugs.gnu.org; Wed, 11 Sep 2024 18:04:17 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1soVRX-0006FI-GA for bug-guile@gnu.org; Wed, 11 Sep 2024 18:04:07 -0400 Received: from dane.soverin.net ([185.233.34.25]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1soVRT-00041M-GH for bug-guile@gnu.org; Wed, 11 Sep 2024 18:04:07 -0400 Received: from smtp.soverin.net (unknown [10.10.4.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by dane.soverin.net (Postfix) with ESMTPS id 4X3vjV3H65z10Vj for ; Wed, 11 Sep 2024 22:03:58 +0000 (UTC) Received: from smtp.soverin.net (smtp.soverin.net [10.10.4.99]) by soverin.net (Postfix) with ESMTPSA id 4X3vjT5YSlz5C for ; Wed, 11 Sep 2024 22:03:57 +0000 (UTC) Authentication-Results: smtp.soverin.net; dkim=pass (2048-bit key; unprotected) header.d=elenq.tech header.i=@elenq.tech header.a=rsa-sha256 header.s=soverin1 header.b=jy77OQLO; dkim-atps=neutral DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=elenq.tech; s=soverin1; t=1726092237; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type:autocrypt:autocrypt; bh=6NtQXEiLN6nbmeSS06wOioIuv7PCZnr+8pFN553dKFQ=; b=jy77OQLOnqxAiaGXDmJkx7HaA+I/qGVV7HiTFIxEexQO693kyh/e4K4PdMUnbms2A8RW69 IHZDxHhdteejoFIyhPQTsSn9S4r3RAXLwqybxsYOC3HpqTM4Qu5Fr6uZgv1M/XZREU4HWz G1xpIxmnVcv/hjqejLuAoC3msLJdkQHQYz38hbfNCHjYEgCIfOuzqTkYDzkfuql1EHN5Hj 0Vu3ggMrkapKCo6YiqU7T+Dlt0msF8qotz12R2WpVtAJjJSeXrXr74s+ZCZuCub+iLj0r8 WAj29i+3fAAG7aqBRdxHaz1dyA3DA7j4U9pzHuyaeGZV01Mn0m+qqwPntUYMrw== Content-Type: multipart/mixed; boundary="------------K7qhRUZlD0lobVe4Y71Rz1L9" Message-ID: <78a81bc5-cd0d-0506-185b-c733c66e96ae@elenq.tech> Date: Thu, 12 Sep 2024 00:03:57 +0200 MIME-Version: 1.0 Content-Language: en-US, es-ES, eu To: "bug-guile@gnu.org" From: Ekaitz Zarraga Subject: PEG parser does not support full PEG grammar Autocrypt: addr=ekaitz@elenq.tech; keydata= xsFNBGViSyIBEADY3g71uW/0CVaVm5/ObqTicQXXJRuh1uafIFiUUZoAp1V3V89b3LZ/m0cL 8YNHxTxsx8sKIMYTGlOvARAMiSpDvkmpf5pLn5T7+VvK90FOv/Pkp1tNNT+tvd0m/7C58+39 s7tN+XppbjVRtFuSXY0aFe8rpivZsKxv+tPUHUnQQszXvwgx0GQl8AX99IE+j75NJmBHFVg2 0geKa7QVymu669ix2+zU8vGoOKf5nIS0qG1m/vrtwR3ZuuyWX9/E/uP95ahX5ETWtjhTDbEm MEaRperwbczBewkdERJ34vRrverqKQA1xHXoPsx4NkLMocORFSSCJsveXcgWlU+pUIOYcKUA ARJjHhoWoUH4LZt5EOb7U17AaYMmATUXPCqq8G3jEXq6i0O1J1obCJGIRG02R9GiGp4zrVuv 2hmyoAmed4xYZAtf9WjcbwiunDkMGIxscdSlfEH/9dt7PGdEvkZ0dNSCTbp4ctMI4jAfobAL LReMSGx1CgPi01J61a/n/SgR66AiRJZCyC1u2V7AK1rBOAYzOU4UoePz+yF1I7crjZWAQVo6 DlmmXW+29l/lh2oK5jOuNEcvI6qi+tPCYxpDhUhZeYgqFU+/xgGlMj/XGvwuIFlpVg9ovFMg 6mxskOCVP9xNEp/qHiHqByYu5NRcITo/z/3BUimdXTT4KSq2cQARAQABzSJFa2FpdHogWmFy cmFnYSA8ZWthaXR6QGVsZW5xLnRlY2g+wsGOBBMBCAA4FiEEg/pnRVjAUpRlfkwZt5lM+Jly CyYFAmViSyICGwMFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQt5lM+JlyCybjZxAAy+YW 3Q22xKoMWJYw03qGCy87WPK+xGWDpKD6TJ77+/IEbldObyQRrKYTTGjQSy6WgaJ0txJMIqeK JyuWuR3bq+Vkh86Byntl25jknOJ+jY1zwPs6HnWFr+hS48FcQh/0D26h57Cqc+6nbKhJcva8 JsInbHTbWPz7wye+xhqY1LfdgVTbCyADESXdmBY30/vP4LzqW81atwYF6X7dN7ko/JvyPPdv VlcspmbP6zNihoApBHdMfJwYscyAsu6tTyL4hMG3zpraeU+S857vZN39gFagRng+uyZG7rfB dHHAFzT1LKOZ4dahavOfA0gS1RZTgtAGsvhUEBn9vKxlB4efZuKhwMtgQEskRFD6JIF1DYCj pLgn5x/y3oI6rn35R46VDhLfohcUWpvzplu6LBft8ZNr+UgoVYc6qBezyDlxk0FmhGI7DEoh gfUxljTALXjSdUGEw2mvp/Mcrz+ffemWpG4+Zq0UXR8sZaHpv+PqmFLFFSQCOCRTYbMKzZBn y03wym3y0tGtunDGm5pR7NEPqUO9QbZdKyTy4ftRkSfTpiPCF8+KKYDT8HimSrusmtTfR4R1 nBJ4lNBYgTdOyJYFbHdF0Jxo9r0t+K2e+6hX6bK79o6aC+/LtzkoYgjCWvAEopO0ras/XQYM S7/bCzeDIhXX5RqmMIp5XN+oBP2roZDOwU0EZWJLIgEQAMIgPDpJY9aOhFiFICx58XMM28An yUPdN39t0A8VkUbsvKXH6eNqUZj/Q3yNcZrknAT1vinv9FN/4uCUnsaqEKp+mRAYgzmNfeJk SWuMzmA04fcISIBz3sJUR0w/59tWi8QxlNn7IR6McAA3lHDXC+KYh9ZfhaOARfan1M6Ppy6g YltUQGSSPXU807inmQZh8GFTi8iUza7vGuBEnaNRGhmhR+blMwHSqVWN4gD81e8dSAEi3zNR sLoBXneHUqTcJMHvsT5cOk7cGMoVAWIffA2EKWfrgda57Qw+w+0OPqWEfKoXwnyt35Tl+Lxl 7MAaAG9R5760yhgkf3LmnBNP3m6StZ8Fv09Gdn5cGSbVnoofHDkg4PQDTD6aGz9af3SnGVg9 nb1Zm1XbqtnYwG9JvQhcjgWAHwrPLkHAcvKtfYWNe4wiirMjXMXxADY08g33SEchPJR2r4pg wttJS4kHUJ2IQUmSH/43RO5PkftWsCucYGeaG1aPr+GAkeKIS1M3OZGuqhd800mltpiH73eL XrUPF8fgngC+SGMrHXLfzuhaRxPNYUbsdF+wRkvjRSO4tCmSVpgfPsHu5emoZgix1iiTO7GF do7L6n1Ay3oF4Witoxc0Gcbu7ltYlZHGmDnsVTVALartsJV2muSXpWcjQiXyC0gUkIkUD/3P jtgVxK8xABEBAAHCwXYEGAEIACAWIQSD+mdFWMBSlGV+TBm3mUz4mXILJgUCZWJLIgIbDAAK CRC3mUz4mXILJrIaD/9CXGckwRCojuRzP0r6+8/RvNDc03CSe2W17WrSaoYgiRb+h5asI/AL yqw+QRgwXZpt0i9hNiDCe/baD62mufIyjKFjHoAWSYJuZ5VK3vWnro6GaxWULYt1+c4c4Lz2 d1nSK6j8F3CxYo7BFk6afOusjYfh+0HywThcYY+x+K5Z+4SdJejDLiL5AzJn2W5Gt/ViK5nI wl7uRQpayMc9zmI8ytUT2NJxovq1/fT9nB8VPwlbJTE9zvIqfqHh9o9Apx5o8yTaSCyGUyu9 8h/klqxFy4HAPJJu/3JkiMaCI45ZdCqRR1LIwhtmW2lb73r0rP/0S1cKi+ehA4oQvwiUw7zh XXw7mqzSAJ0SWT92Vy2G8Z8qqgwxwfQcdFZAyJAL1rgEPQljNT91Vgbc6DCUka2XW5BqyhEB eS0n1gK0hYXbM9FKegRsZxlmRAXa4KGXCwr4BNK6k+zkKPitezjbtcLgcKSHa8/HyHNkW7xH R+MN16x2elQPmQ2d0Ien1HgsK98+3prlUGwZIVCqa1ddSoW0llU3JzGsKrMAiYbWg/rOXFil RJbuhjflaLBVmfI8VlRQRocP+WEH0lsUWrtjVaGcBj1/YnIoT+zT6fPSXwPsrBvAWEjfl8HH e1F4cYb+ugPDwUTd1s2Uj2tF0/fhCHPy9sXyx/EIL3gqyBw9M2Rz9A== X-Spampanel-Class: ham Received-SPF: pass client-ip=185.233.34.25; envelope-from=ekaitz@elenq.tech; helo=dane.soverin.net X-Spam_score_int: -27 X-Spam_score: -2.8 X-Spam_bar: -- X-Spam_report: (-2.8 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_VALIDITY_RPBL_BLOCKED=0.001, RCVD_IN_VALIDITY_SAFE_BLOCKED=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-Spam-Score: -1.3 (-) X-Debbugs-Envelope-To: submit X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -2.3 (--) This is a multi-part message in MIME format. --------------K7qhRUZlD0lobVe4Y71Rz1L9 Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 7bit Hi, I noticed the PEG parser does not support the full PEG grammar, this includes comments, double quotes, escaping and underscores. The attached patch adds support for those (I sent it to guile-devel but I guess it's better to do it here). I'm trying to test it with Zig's grammar but I'm having some issues and the way this is generated it's really hard to test. As is, this patch passes all the current tests in Guile which includes being able to parse peg-as-peg, which now has comments and features that were not implemented before. Thank you, Ekaitz --------------K7qhRUZlD0lobVe4Y71Rz1L9 Content-Type: text/x-patch; charset=UTF-8; name="0001-PEG-Add-full-support-for-PEG-some-extensions.patch" Content-Disposition: attachment; filename="0001-PEG-Add-full-support-for-PEG-some-extensions.patch" Content-Transfer-Encoding: base64 RnJvbSAyZWVmNjZmZmRmYzA3MjhhODRmYTFlOGEzN2IyYTc0OGJmNDY0MzI0IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBFa2FpdHogWmFycmFnYSA8ZWthaXR6QGVsZW5xLnRl Y2g+CkRhdGU6IFdlZCwgMTEgU2VwIDIwMjQgMjE6MTk6MjYgKzAyMDAKU3ViamVjdDogW1BB VENIXSBQRUc6IEFkZCBmdWxsIHN1cHBvcnQgZm9yIFBFRyArIHNvbWUgZXh0ZW5zaW9ucwoK VGhpcyBjb21taXQgYWRkcyBzdXBwb3J0IGZvciBQRUcgYXMgZGVzY3JpYmVkIGluOgoKICAg IDxodHRwczovL2Jmb3JkLmluZm8vcHViL2xhbmcvcGVnLnBkZj4KCkl0IGFkZHMgc3VwcG9y dCBmb3IgdGhlIG1pc3NpbmcgZmVhdHVyZXMgKGNvbW1lbnRzLCB1bmRlcnNjb3JlcyBpbgpp ZGVudGlmaWVycyBhbmQgZXNjYXBpbmcpIHdoaWxlIGtlZXBpbmcgdGhlIGV4dGVuc2lvbnMg KGRhc2hlcyBpbgppZGVudGlmaWVycywgPCBhbmQgPC0tKS4KClRoZSBuYW1pbmcgc3lzdGVt IHRyaWVzIHRvIGJlIGFzIGNsb3NlIGFzIHBvc3NpYmxlIHRvIHRoZSBvbmUgcHJvcG9zZWQK aW4gdGhlIHBhcGVyLgoKKiBtb2R1bGUvaWNlLTkvcGVnL3N0cmluZy1wZWcuc2NtOiBSZXdy aXRlIFBFRyBwYXJzZXIuCiogdGVzdC1zdWl0ZS90ZXN0cy9wZWcudGVzdDogRml4IGltcG9y dAotLS0KIG1vZHVsZS9pY2UtOS9wZWcvc3RyaW5nLXBlZy5zY20gfCA0MTAgKysrKysrKysr KysrKysrKysrKy0tLS0tLS0tLS0tLS0KIHRlc3Qtc3VpdGUvdGVzdHMvcGVnLnRlc3QgICAg ICAgfCAgMzIgKystCiAyIGZpbGVzIGNoYW5nZWQsIDI2MyBpbnNlcnRpb25zKCspLCAxNzkg ZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvbW9kdWxlL2ljZS05L3BlZy9zdHJpbmctcGVn LnNjbSBiL21vZHVsZS9pY2UtOS9wZWcvc3RyaW5nLXBlZy5zY20KaW5kZXggNDVlZDE0YmIx Li40NzIwMjA2NGIgMTAwNjQ0Ci0tLSBhL21vZHVsZS9pY2UtOS9wZWcvc3RyaW5nLXBlZy5z Y20KKysrIGIvbW9kdWxlL2ljZS05L3BlZy9zdHJpbmctcGVnLnNjbQpAQCAtMSw2ICsxLDYg QEAKIDs7Ozsgc3RyaW5nLXBlZy5zY20gLS0tIHJlcHJlc2VudGluZyBQRUcgZ3JhbW1hcnMg YXMgc3RyaW5ncwogOzs7OwotOzs7OyAJQ29weXJpZ2h0IChDKSAyMDEwLCAyMDExIEZyZWUg U29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLgorOzs7OyAJQ29weXJpZ2h0IChDKSAyMDEwLCAy MDExLCAyMDIzIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLgogOzs7OwogOzs7OyBU aGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQg YW5kL29yCiA7Ozs7IG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNz ZXIgR2VuZXJhbCBQdWJsaWMKQEAgLTIyLDYgKzIyLDcgQEAKICAgICAgICAgICAgIGRlZmlu ZS1wZWctc3RyaW5nLXBhdHRlcm5zCiAgICAgICAgICAgICBwZWctZ3JhbW1hcikKICAgIzp1 c2UtbW9kdWxlIChpY2UtOSBwZWcgdXNpbmctcGFyc2VycykKKyAgIzp1c2UtbW9kdWxlIChz cmZpIHNyZmktMSkKICAgIzp1c2UtbW9kdWxlIChpY2UtOSBwZWcgY29kZWdlbikKICAgIzp1 c2UtbW9kdWxlIChpY2UtOSBwZWcgc2ltcGxpZnktdHJlZSkpCiAKQEAgLTM4LDIxICszOSw1 NSBAQAogCiA7OyBHcmFtbWFyIGZvciBQRUdzIGluIFBFRyBncmFtbWFyLgogKGRlZmluZSBw ZWctYXMtcGVnCi0iZ3JhbW1hciA8LS0gKG5vbnRlcm1pbmFsICgnPC0tJyAvICc8LScgLyAn PCcpIHNwIHBhdHRlcm4pKwotcGF0dGVybiA8LS0gYWx0ZXJuYXRpdmUgKFNMQVNIIHNwIGFs dGVybmF0aXZlKSoKLWFsdGVybmF0aXZlIDwtLSAoWyEmXT8gc3Agc3VmZml4KSsKLXN1ZmZp eCA8LS0gcHJpbWFyeSAoWyorP10gc3ApKgotcHJpbWFyeSA8LS0gJygnIHNwIHBhdHRlcm4g JyknIHNwIC8gJy4nIHNwIC8gbGl0ZXJhbCAvIGNoYXJjbGFzcyAvIG5vbnRlcm1pbmFsICEn PCcKLWxpdGVyYWwgPC0tIFsnXSAoIVsnXSAuKSogWyddIHNwCi1jaGFyY2xhc3MgPC0tIExC ICghJ10nIChDQ3JhbmdlIC8gQ0NzaW5nbGUpKSogUkIgc3AKLUNDcmFuZ2UgPC0tIC4gJy0n IC4KLUNDc2luZ2xlIDwtLSAuCi1ub250ZXJtaW5hbCA8LS0gW2EtekEtWjAtOS1dKyBzcAot c3AgPCBbIFx0XG5dKgotU0xBU0ggPCAnLycKLUxCIDwgJ1snCi1SQiA8ICddJwotIikKKyIj IEhpZXJhcmNoaWNhbCBzeW50YXgKK0dyYW1tYXIgPC0tIFNwYWNpbmcgRGVmaW5pdGlvbisg RW5kT2ZGaWxlCitEZWZpbml0aW9uIDwtLSBJZGVudGlmaWVyIExFRlRBUlJPVyBFeHByZXNz aW9uCisKK0V4cHJlc3Npb24gPC0tIFNlcXVlbmNlIChTTEFTSCBTZXF1ZW5jZSkqCitTZXF1 ZW5jZSA8LS0gUHJlZml4KgorUHJlZml4IDwtLSAoQU5EIC8gTk9UKT8gU3VmZml4CitTdWZm aXggPC0tIFByaW1hcnkgKFFVRVNUSU9OIC8gU1RBUiAvIFBMVVMpPworUHJpbWFyeSA8LS0g SWRlbnRpZmllciAhTEVGVEFSUk9XCisgICAgICAgICAgIC8gT1BFTiBFeHByZXNzaW9uIENM T1NFCisgICAgICAgICAgIC8gTGl0ZXJhbCAvIENsYXNzIC8gRE9UCisKKyMgTGV4aWNhbCBz eW50YXgKK0lkZW50aWZpZXIgPC0tIElkZW50U3RhcnQgSWRlbnRDb250KiBTcGFjaW5nCisj IE5PVEU6IGAtYCBpcyBhbiBleHRlbnNpb24KK0lkZW50U3RhcnQgPC0gW2EtekEtWl8tXQor SWRlbnRDb250IDwtIElkZW50U3RhcnQgLyBbMC05XQorCitMaXRlcmFsIDwtLSBTUVVPVEUg KCFTUVVPVEUgQ2hhcikqIFNRVU9URSBTcGFjaW5nCisgICAgICAgIC8gRFFVT1RFICghRFFV T1RFIENoYXIpKiBEUVVPVEUgU3BhY2luZworQ2xhc3MgPC0tICdbJyAoISddJyBSYW5nZSkq ICddJyBTcGFjaW5nCitSYW5nZSA8LS0gQ2hhciAnLScgQ2hhciAvIENoYXIKK0NoYXIgPC0t ICdcXFxcJyBbbnJ0J1wiXFxbXFxdXFxcXF0KKyAgICAgICAvICdcXFxcJyBbMC0yXVswLTdd WzAtN10KKyAgICAgICAvICdcXFxcJyBbMC03XVswLTddPworICAgICAgIC8gISdcXFxcJyAu CisKKyMgTk9URTogYDwtLWAgYW5kIGA8YCBhcmUgZXh0ZW5zaW9ucworTEVGVEFSUk9XIDwt ICgnPC0tJyAvICc8LScgLyAnPCcpIFNwYWNpbmcKK1NRVU9URSA8LS0gWyddCitEUVVPVEUg PC0tIFtcIl0KK09QRU5CUkFDS0VUIDwgJ1snCitDTE9TRUJSQUNLRVQgPCAnXScKK1NMQVNI IDwgJy8nIFNwYWNpbmcKK0FORCA8LS0gJyYnIFNwYWNpbmcKK05PVCA8LS0gJyEnIFNwYWNp bmcKK1FVRVNUSU9OIDwtLSAnPycgU3BhY2luZworU1RBUiA8LS0gJyonIFNwYWNpbmcKK1BM VVMgPC0tICcrJyBTcGFjaW5nCitPUEVOIDwgJygnIFNwYWNpbmcKK0NMT1NFIDwgJyknIFNw YWNpbmcKK0RPVCA8LS0gJy4nIFNwYWNpbmcKKworU3BhY2luZyA8IChTcGFjZSAvIENvbW1l bnQpKgorQ29tbWVudCA8ICcjJyAoIUVuZE9mTGluZSAuKSogRW5kT2ZMaW5lCitTcGFjZSA8 ICcgJyAvICdcdCcgLyBFbmRPZkxpbmUKK0VuZE9mTGluZSA8ICdcclxuJyAvICdcbicgLyAn XHInCitFbmRPZkZpbGUgPCAhLiIpCisKIAogKGRlZmluZS1zeW50YXggZGVmaW5lLXNleHAt cGFyc2VyCiAgIChsYW1iZGEgKHgpCkBAIC02MywzNSArOTgsNzggQEAgUkIgPCAnXScKICAg ICAgICAgICAgICAgKHN5biAod3JhcC1wYXJzZXItZm9yLXVzZXJzIHggbWF0Y2hmIGFjY3Vt c3ltICMnc3ltKSkpCiAgICAgICAgICAgICNgKGRlZmluZSBzeW0gIyxzeW4pKSkpKSkKIAot KGRlZmluZS1zZXhwLXBhcnNlciBwZWctZ3JhbW1hciBhbGwKLSAgKCsgKGFuZCBwZWctbm9u dGVybWluYWwgKG9yICI8LS0iICI8LSIgIjwiKSBwZWctc3AgcGVnLXBhdHRlcm4pKSkKLShk ZWZpbmUtc2V4cC1wYXJzZXIgcGVnLXBhdHRlcm4gYWxsCi0gIChhbmQgcGVnLWFsdGVybmF0 aXZlCi0gICAgICAgKCogKGFuZCAoaWdub3JlICIvIikgcGVnLXNwIHBlZy1hbHRlcm5hdGl2 ZSkpKSkKLShkZWZpbmUtc2V4cC1wYXJzZXIgcGVnLWFsdGVybmF0aXZlIGFsbAotICAoKyAo YW5kICg/IChvciAiISIgIiYiKSkgcGVnLXNwIHBlZy1zdWZmaXgpKSkKLShkZWZpbmUtc2V4 cC1wYXJzZXIgcGVnLXN1ZmZpeCBhbGwKLSAgKGFuZCBwZWctcHJpbWFyeSAoKiAoYW5kIChv ciAiKiIgIisiICI/IikgcGVnLXNwKSkpKQotKGRlZmluZS1zZXhwLXBhcnNlciBwZWctcHJp bWFyeSBhbGwKLSAgKG9yIChhbmQgIigiIHBlZy1zcCBwZWctcGF0dGVybiAiKSIgcGVnLXNw KQotICAgICAgKGFuZCAiLiIgcGVnLXNwKQotICAgICAgcGVnLWxpdGVyYWwKLSAgICAgIHBl Zy1jaGFyY2xhc3MKLSAgICAgIChhbmQgcGVnLW5vbnRlcm1pbmFsIChub3QtZm9sbG93ZWQt YnkgIjwiKSkpKQotKGRlZmluZS1zZXhwLXBhcnNlciBwZWctbGl0ZXJhbCBhbGwKLSAgKGFu ZCAiJyIgKCogKGFuZCAobm90LWZvbGxvd2VkLWJ5ICInIikgcGVnLWFueSkpICInIiBwZWct c3ApKQotKGRlZmluZS1zZXhwLXBhcnNlciBwZWctY2hhcmNsYXNzIGFsbAotICAoYW5kIChp Z25vcmUgIlsiKQotICAgICAgICgqIChhbmQgKG5vdC1mb2xsb3dlZC1ieSAiXSIpCi0gICAg ICAgICAgICAgICAob3IgY2hhcmNsYXNzLXJhbmdlIGNoYXJjbGFzcy1zaW5nbGUpKSkKLSAg ICAgICAoaWdub3JlICJdIikKLSAgICAgICBwZWctc3ApKQotKGRlZmluZS1zZXhwLXBhcnNl ciBjaGFyY2xhc3MtcmFuZ2UgYWxsIChhbmQgcGVnLWFueSAiLSIgcGVnLWFueSkpCi0oZGVm aW5lLXNleHAtcGFyc2VyIGNoYXJjbGFzcy1zaW5nbGUgYWxsIHBlZy1hbnkpCi0oZGVmaW5l LXNleHAtcGFyc2VyIHBlZy1ub250ZXJtaW5hbCBhbGwKLSAgKGFuZCAoKyAob3IgKHJhbmdl ICNcYSAjXHopIChyYW5nZSAjXEEgI1xaKSAocmFuZ2UgI1wwICNcOSkgIi0iKSkgcGVnLXNw KSkKLShkZWZpbmUtc2V4cC1wYXJzZXIgcGVnLXNwIG5vbmUKLSAgKCogKG9yICIgIiAiXHQi ICJcbiIpKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgR3JhbW1hciBhbGwKKyAgKGFuZCBTcGFj aW5nICgrIERlZmluaXRpb24pIEVuZE9mRmlsZSkpCisoZGVmaW5lLXNleHAtcGFyc2VyIERl ZmluaXRpb24gYWxsCisgIChhbmQgSWRlbnRpZmllciBMRUZUQVJST1cgRXhwcmVzc2lvbikp CisoZGVmaW5lLXNleHAtcGFyc2VyIEV4cHJlc3Npb24gYWxsCisgIChhbmQgU2VxdWVuY2Ug KCogKGFuZCBTTEFTSCBTZXF1ZW5jZSkpKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgU2VxdWVu Y2UgYWxsCisgICgqIFByZWZpeCkpCisoZGVmaW5lLXNleHAtcGFyc2VyIFByZWZpeCBhbGwK KyAgKGFuZCAoPyAob3IgQU5EIE5PVCkpIFN1ZmZpeCkpCisoZGVmaW5lLXNleHAtcGFyc2Vy IFN1ZmZpeCBhbGwKKyAgKGFuZCBQcmltYXJ5ICg/IChvciBRVUVTVElPTiBTVEFSIFBMVVMp KSkpCisoZGVmaW5lLXNleHAtcGFyc2VyIFByaW1hcnkgYWxsCisgIChvciAoYW5kIElkZW50 aWZpZXIgKG5vdC1mb2xsb3dlZC1ieSBMRUZUQVJST1cpKQorICAgICAgKGFuZCBPUEVOIEV4 cHJlc3Npb24gQ0xPU0UpCisgICAgICBMaXRlcmFsCisgICAgICBDbGFzcworICAgICAgRE9U KSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgSWRlbnRpZmllciBhbGwKKyAgKGFuZCBJZGVudFN0 YXJ0ICgqIElkZW50Q29udCkgU3BhY2luZykpCisoZGVmaW5lLXNleHAtcGFyc2VyIElkZW50 U3RhcnQgYm9keQorICAob3IgKHJhbmdlICNcYSAjXHopIChyYW5nZSAjXEEgI1xaKSAiXyIg Ii0iKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgSWRlbnRDb250IGJvZHkKKyAgKG9yIElkZW50 U3RhcnQgKHJhbmdlICNcMCAjXDkpKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgTGl0ZXJhbCBh bGwKKyAgKG9yIChhbmQgU1FVT1RFICgqIChhbmQgKG5vdC1mb2xsb3dlZC1ieSBTUVVPVEUp IENoYXIpKSBTUVVPVEUgU3BhY2luZykKKyAgICAgIChhbmQgRFFVT1RFICgqIChhbmQgKG5v dC1mb2xsb3dlZC1ieSBEUVVPVEUpIENoYXIpKSBEUVVPVEUgU3BhY2luZykpKQorKGRlZmlu ZS1zZXhwLXBhcnNlciBDbGFzcyBhbGwKKyAgKGFuZCBPUEVOQlJBQ0tFVCAoKiAoYW5kIChu b3QtZm9sbG93ZWQtYnkgQ0xPU0VCUkFDS0VUKSBSYW5nZSkpIENMT1NFQlJBQ0tFVCBTcGFj aW5nKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgUmFuZ2UgYWxsCisgIChvciAoYW5kIENoYXIg REFTSCBDaGFyKSBDaGFyKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgQ2hhciBhbGwKKyAgKG9y IChhbmQgIlxcIiAob3IgIm4iICJyIiAidCIgIiciICJbIiAiXSIgIlxcIikpCisgICAgICAo YW5kICJcXCIgKHJhbmdlICNcMCAjXDIpIChyYW5nZSAjXDAgI1w3KSAocmFuZ2UgI1wwICNc NykpCisgICAgICAoYW5kICJcXCIgKHJhbmdlICNcMCAjXDcpICg/IChyYW5nZSAjXDAgI1w3 KSkpCisgICAgICAoYW5kIChub3QtZm9sbG93ZWQtYnkgIlxcIikgcGVnLWFueSkpKQorKGRl ZmluZS1zZXhwLXBhcnNlciBMRUZUQVJST1cgYm9keQorICAoYW5kIChvciAiPC0tIiAiPC0i ICI8IikgU3BhY2luZykpIDsgTk9URTogPC0tIGFuZCA8IGFyZSBleHRlbnNpb25zCisoZGVm aW5lLXNleHAtcGFyc2VyIFNMQVNIIG5vbmUKKyAgKGFuZCAiLyIgU3BhY2luZykpCisoZGVm aW5lLXNleHAtcGFyc2VyIEFORCBhbGwKKyAgKGFuZCAiJiIgU3BhY2luZykpCisoZGVmaW5l LXNleHAtcGFyc2VyIE5PVCBhbGwKKyAgKGFuZCAiISIgU3BhY2luZykpCisoZGVmaW5lLXNl eHAtcGFyc2VyIFFVRVNUSU9OIGFsbAorICAoYW5kICI/IiBTcGFjaW5nKSkKKyhkZWZpbmUt c2V4cC1wYXJzZXIgU1RBUiBhbGwKKyAgKGFuZCAiKiIgU3BhY2luZykpCisoZGVmaW5lLXNl eHAtcGFyc2VyIFBMVVMgYWxsCisgIChhbmQgIisiIFNwYWNpbmcpKQorKGRlZmluZS1zZXhw LXBhcnNlciBPUEVOIG5vbmUKKyAgKGFuZCAiKCIgU3BhY2luZykpCisoZGVmaW5lLXNleHAt cGFyc2VyIENMT1NFIG5vbmUKKyAgKGFuZCAiKSIgU3BhY2luZykpCisoZGVmaW5lLXNleHAt cGFyc2VyIERPVCBhbGwKKyAgKGFuZCAiLiIgU3BhY2luZykpCisoZGVmaW5lLXNleHAtcGFy c2VyIFNRVU9URSBub25lICInIikKKyhkZWZpbmUtc2V4cC1wYXJzZXIgRFFVT1RFIG5vbmUg IlwiIikKKyhkZWZpbmUtc2V4cC1wYXJzZXIgT1BFTkJSQUNLRVQgbm9uZSAiWyIpCisoZGVm aW5lLXNleHAtcGFyc2VyIENMT1NFQlJBQ0tFVCBub25lICJdIikKKyhkZWZpbmUtc2V4cC1w YXJzZXIgREFTSCBub25lICItIikKKyhkZWZpbmUtc2V4cC1wYXJzZXIgU3BhY2luZyBub25l CisgICgqIChvciBTcGFjZSBDb21tZW50KSkpCisoZGVmaW5lLXNleHAtcGFyc2VyIENvbW1l bnQgbm9uZQorICAoYW5kICIjIiAoKiAoYW5kIChub3QtZm9sbG93ZWQtYnkgRW5kT2ZMaW5l KSBwZWctYW55KSkgRW5kT2ZMaW5lKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgU3BhY2Ugbm9u ZQorICAob3IgIiAiICJcdCIgRW5kT2ZMaW5lKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgRW5k T2ZMaW5lIG5vbmUKKyAgKG9yICJcclxuIiAiXG4iICJcciIpKQorKGRlZmluZS1zZXhwLXBh cnNlciBFbmRPZkZpbGUgbm9uZQorICAobm90LWZvbGxvd2VkLWJ5IHBlZy1hbnkpKQorCiAK IDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7 Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7CiA7Ozs7OyBQQVJTRSBTVFJJTkcgUEVHUwpA QCAtMTAxLDcgKzE3OSw3IEBAIFJCIDwgJ10nCiA7OyB3aWxsIGRlZmluZSBhbGwgb2YgdGhl IG5vbnRlcm1pbmFscyBpbiB0aGUgZ3JhbW1hciB3aXRoIGVxdWl2YWxlbnQKIDs7IFBFRyBz LWV4cHJlc3Npb25zLgogKGRlZmluZSAocGVnLXBhcnNlciBzdHIgZm9yLXN5bnRheCkKLSAg KGxldCAoKHBhcnNlZCAobWF0Y2gtcGF0dGVybiBwZWctZ3JhbW1hciBzdHIpKSkKKyAgKGxl dCAoKHBhcnNlZCAobWF0Y2gtcGF0dGVybiBHcmFtbWFyIHN0cikpKQogICAgIChpZiAobm90 IHBhcnNlZCkKICAgICAgICAgKGJlZ2luCiAgICAgICAgICAgOzsgKGRpc3BsYXkgIkludmFs aWQgUEVHIGdyYW1tYXIhXG4iKQpAQCAtMTEwLDExICsxODgsMTIzIEBAIFJCIDwgJ10nCiAg ICAgICAgICAgKGNvbmQKICAgICAgICAgICAgKChvciAobm90IChsaXN0PyBsc3QpKSAobnVs bD8gbHN0KSkKICAgICAgICAgICAgIGxzdCkKLSAgICAgICAgICAgKChlcT8gKGNhciBsc3Qp ICdwZWctZ3JhbW1hcikKLSAgICAgICAgICAgICNgKGJlZ2luCi0gICAgICAgICAgICAgICAg IyxAKG1hcCAobGFtYmRhICh4KSAocGVnLW5vbnRlcm0tPmRlZm4geCBmb3Itc3ludGF4KSkK LSAgICAgICAgICAgICAgICAgICAgICAgIChjb250ZXh0LWZsYXR0ZW4gKGxhbWJkYSAobHN0 KSAoPD0gKGRlcHRoIGxzdCkgMikpCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIChjZHIgbHN0KSkpKSkpKSkpKQorICAgICAgICAgICAoKGVxPyAoY2FyIGxz dCkgJ0dyYW1tYXIpCisgICAgICAgICAgICAoR3JhbW1hci0+ZGVmbiBsc3QgZm9yLXN5bnRh eCkpKSkpKSkKKworOzsgKEdyYW1tYXIgKERlZmluaXRpb24gLi4uKSAoRGVmaW5pdGlvbiAu Li4pKQorKGRlZmluZSAoR3JhbW1hci0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKKyAgI2AoYmVn aW4KKyAgICAgICMsQChtYXAgKGxhbWJkYSAoeCkgKERlZmluaXRpb24tPmRlZm4geCBmb3It c3ludGF4KSkKKyAgICAgICAgICAgICAgKGNvbnRleHQtZmxhdHRlbiAobGFtYmRhIChsc3Qp ICg8PSAoZGVwdGggbHN0KSAxKSkKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAo Y2RyIGxzdCkpKSkpCisKKzs7IChEZWZpbml0aW9uIChJZGVudGlmaWVyICJTb21ldGhpbmci KSAiPC0iIChFeHByZXNzaW9uIC4uLikpCis7OyAgYC0+IChkZWZpbmUtcGVnLXBhdHRlcm4g U29tZXRoaW5nICdhbGwgLi4uKQorKGRlZmluZSAoRGVmaW5pdGlvbi0+ZGVmbiBsc3QgZm9y LXN5bnRheCkKKyAgKGxldCAoKGlkZW50aWZpZXIgKHNlY29uZCAoc2Vjb25kIGxzdCkpKQor ICAgICAgICAoZ3JhYmJlciAgICAodGhpcmQgIGxzdCkpCisgICAgICAgIChleHByZXNzaW9u IChmb3VydGggbHN0KSkpCisgICAgI2AoZGVmaW5lLXBlZy1wYXR0ZXJuICMsKGRhdHVtLT5z eW50YXggZm9yLXN5bnRheAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIChzdHJpbmctPnN5bWJvbCBpZGVudGlmaWVyKSkKKyAgICAgICAjLChjb25kCisg ICAgICAgICAgKChzdHJpbmc9PyBncmFiYmVyICI8LS0iKSAoZGF0dW0tPnN5bnRheCBmb3It c3ludGF4ICdhbGwpKQorICAgICAgICAgICgoc3RyaW5nPT8gZ3JhYmJlciAiPC0iKSAoZGF0 dW0tPnN5bnRheCBmb3Itc3ludGF4ICdib2R5KSkKKyAgICAgICAgICAoZWxzZSAoZGF0dW0t PnN5bnRheCBmb3Itc3ludGF4ICdub25lKSkpCisgICAgICAgIywoY29tcHJlc3NvciAoRXhw cmVzc2lvbi0+ZGVmbiBleHByZXNzaW9uIGZvci1zeW50YXgpIGZvci1zeW50YXgpKSkpCisK Kzs7IChFeHByZXNzaW9uIChTZXF1ZW5jZSBYKSkKKzs7ICBgLT4gKFgpCis7OyAoRXhwcmVz c2lvbiAoU2VxdWVuY2UgWCkgKFNlcXVlbmNlIFkpKQorOzsgIGAtPiAob3IgWCBZKQorOzsg KEV4cHJlc3Npb24gKFNlcXVlbmNlIFgpICgoU2VxdWVuY2UgWSkgKFNlcXVlbmNlIFopIC4u LikpCis7OyAgYC0+IChvciBYIFkgWiAuLi4pCisoZGVmaW5lIChFeHByZXNzaW9uLT5kZWZu IGxzdCBmb3Itc3ludGF4KQorICAobGV0ICgoZmlyc3Qtc2VxdWVuY2UgKHNlY29uZCBsc3Qp KQorICAgICAgICAocmVzdCAgICAgICAgICAgKGNkZHIgIGxzdCkpKQorICAgICNgKG9yICMs KFNlcXVlbmNlLT5kZWZuIGZpcnN0LXNlcXVlbmNlIGZvci1zeW50YXgpCisgICAgICAgICAg IyxAKG1hcCAobGFtYmRhICh4KQorICAgICAgICAgICAgICAgICAgICAoU2VxdWVuY2UtPmRl Zm4geCBmb3Itc3ludGF4KSkKKyAgICAgICAgICAgICAgICAgIChrZXl3b3JkLWZsYXR0ZW4g JyhTZXF1ZW5jZSkgcmVzdCkpKSkpCisKKworKGRlZmluZSAoU2VxdWVuY2UtPmRlZm4gbHN0 IGZvci1zeW50YXgpCisgICNgKGFuZCAjLEAobWFwIChsYW1iZGEgKHgpIChQcmVmaXgtPmRl Zm4geCBmb3Itc3ludGF4KSkgKGNkciBsc3QpKSkpCisKKworOzsgKFByZWZpeCAoU3VmZml4 IC4uLikpCis7OyAgYC0+ICguLi4pCis7OyAoUHJlZml4IChOT1QgIiEiKSAoU3VmZml4IC4u LikpCis7OyAgYC0+IChub3QtZm9sbG93ZWQtYnkgLi4uKQorOzsgKFByZWZpeCAoQU5EICIm IikgKFN1ZmZpeCAuLi4pKQorOzsgIGAtPiAoZm9sbG93ZWQtYnkgLi4uKQorKGRlZmluZSAo UHJlZml4LT5kZWZuIGxzdCBmb3Itc3ludGF4KQorICAobGV0ICgoc3VmZml4IChzZWNvbmQg bHN0KSkpCisgICAgKGNhc2UgKGNhciBzdWZmaXgpCisgICAgICAoJ0FORCAjYChmb2xsb3dl ZC1ieSAjLChTdWZmaXgtPmRlZm4gKHRoaXJkIGxzdCkgZm9yLXN5bnRheCkpKQorICAgICAg KCdOT1QgI2Aobm90LWZvbGxvd2VkLWJ5ICMsKFN1ZmZpeC0+ZGVmbiAodGhpcmQgbHN0KSBm b3Itc3ludGF4KSkpCisgICAgICAoZWxzZSAoU3VmZml4LT5kZWZuIHN1ZmZpeCBmb3Itc3lu dGF4KSkpKSkKKworOzsgKFN1ZmZpeCAoUHJpbWFyeSAuLi4pKQorOzsgIGAtPiAoLi4uKQor OzsgKFN1ZmZpeCAoUHJpbWFyeSAuLi4pIChTVEFSICIqIikpCis7OyAgYC0+ICgqIC4uLikK Kzs7IChTdWZmaXggKFByaW1hcnkgLi4uKSAoUVVFU1RJT04gIj8iKSkKKzs7ICBgLT4gKD8g Li4uKQorOzsgKFN1ZmZpeCAoUHJpbWFyeSAuLi4pIChQTFVTICIrIikpCis7OyAgYC0+ICgr IC4uLikKKyhkZWZpbmUgKFN1ZmZpeC0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKKyAgKGxldCog KChwcmltYXJ5IChzZWNvbmQgbHN0KSkKKyAgICAgICAgIChvdXQgICAgIChQcmltYXJ5LT5k ZWZuIHByaW1hcnkgZm9yLXN5bnRheCkpCisgICAgICAgICAoZXh0cmEgICAoY2RkciBsc3Qp KSkKKyAgICAoaWYgKG51bGw/IGV4dHJhKQorICAgICAgb3V0CisgICAgICAoY2FzZSAoY2Fh ciBleHRyYSkKKyAgICAgICAgKCdRVUVTVElPTiAjYCg/ICMsb3V0KSkKKyAgICAgICAgKCdT VEFSICAgICAjYCgqICMsb3V0KSkKKyAgICAgICAgKCdQTFVTICAgICAjYCgrICMsb3V0KSkp KSkpCisKKyhkZWZpbmUgKFByaW1hcnktPmRlZm4gbHN0IGZvci1zeW50YXgpCisgIChsZXQg KCh2YWx1ZSAoc2Vjb25kIGxzdCkpKQorICAgIChjYXNlIChjYXIgdmFsdWUpCisgICAgICAo J0RPVCAgICAgICAgIydwZWctYW55KQorICAgICAgKCdJZGVudGlmaWVyIChJZGVudGlmaWVy LT5kZWZuIHZhbHVlIGZvci1zeW50YXgpKQorICAgICAgKCdFeHByZXNzaW9uIChFeHByZXNz aW9uLT5kZWZuIHZhbHVlIGZvci1zeW50YXgpKQorICAgICAgKCdMaXRlcmFsICAgIChMaXRl cmFsLT5kZWZuIHZhbHVlIGZvci1zeW50YXgpKQorICAgICAgKCdDbGFzcyAgICAgIChDbGFz cy0+ZGVmbiB2YWx1ZSBmb3Itc3ludGF4KSkpKSkKKworOzsgKElkZW50aWZpZXIgImhlbGxv IikKKzs7ICBgLT4gaGVsbG8KKyhkZWZpbmUgKElkZW50aWZpZXItPmRlZm4gbHN0IGZvci1z eW50YXgpCisgIChkYXR1bS0+c3ludGF4IGZvci1zeW50YXggKHN0cmluZy0+c3ltYm9sIChz ZWNvbmQgbHN0KSkpKQorCis7OyAoTGl0ZXJhbCAoQ2hhciAiYSIpIChDaGFyICJiIikgKENo YXIgImMiKSkKKzs7ICBgLT4gImFiYyIKKyhkZWZpbmUgKExpdGVyYWwtPmRlZm4gbHN0IGZv ci1zeW50YXgpCisgIChhcHBseSBzdHJpbmctYXBwZW5kIChtYXAgc2Vjb25kIChjZHIgbHN0 KSkpKQorCis7OyBUT0RPOiBlbXB0eSBDbGFzcyBjYW4gaGFwcGVuOiBgW11gLCBidXQgd2hh dCBkb2VzIGl0IHJlcHJlc2VudD8KKzs7IChDbGFzcyAuLi4pCis7OyAgYC0+IChvciAuLi4p CisoZGVmaW5lIChDbGFzcy0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKKyAgI2Aob3IgIyxAKG1h cCAobGFtYmRhICh4KQorICAgICAgICAgICAgICAgICAgKFJhbmdlLT5kZWZuIHggZm9yLXN5 bnRheCkpCisgICAgICAgICAgICAgICAgKGNkciBsc3QpKSkpCisKKzs7IEZvciBvbmUgY2hh cmFjdGVyOgorOzsgKFJhbmdlIChDaGFyICJhIikpCis7OyAgYC0+ICJhIgorOzsgT3IgZm9y IGEgcmFuZ2U6Cis7OyAoUmFuZ2UgKENoYXIgImEiKSAoQ2hhciAiYiIpKQorOzsgIGAtPiAo cmFuZ2UgI1xhICNcYikKKyhkZWZpbmUgKFJhbmdlLT5kZWZuIGxzdCBmb3Itc3ludGF4KQor ICAoY29uZAorICAgICgoPSAyIChsZW5ndGggbHN0KSkKKyAgICAgKHNlY29uZCAoc2Vjb25k IGxzdCkpKQorICAgICgoPSAzIChsZW5ndGggbHN0KSkKKyAgICAgI2AocmFuZ2UgIywoc3Ry aW5nLXJlZiAoc2Vjb25kIChzZWNvbmQgbHN0KSkgMCkKKyAgICAgICAgICAgICAgIywoc3Ry aW5nLXJlZiAoc2Vjb25kICh0aGlyZCBsc3QpKSAwKSkpKSkKKworKGRlZmluZSBwZWctZ3Jh bW1hciBHcmFtbWFyKQogCiA7OyBNYWNybyB3cmFwcGVyIGZvciBQRUctUEFSU0VSLiAgUGFy c2VzIFBFRyBncmFtbWFycyBleHByZXNzZWQgYXMgc3RyaW5ncyBhbmQKIDs7IGRlZmluZXMg YWxsIHRoZSBhcHByb3ByaWF0ZSBub250ZXJtaW5hbHMuCkBAIC0xMjQsMTE5ICszMTQsNiBA QCBSQiA8ICddJwogICAgICAgKChfIHN0cikKICAgICAgICAocGVnLXBhcnNlciAoc3ludGF4 LT5kYXR1bSAjJ3N0cikgeCkpKSkpCiAKLTs7IGxzdCBoYXMgZm9ybWF0IChub250ZXJtIGdy YWJiZXIgcGF0dGVybiksIHdoZXJlCi07OyAgIG5vbnRlcm0gaXMgYSBzeW1ib2wgKHRoZSBu YW1lIG9mIHRoZSBub250ZXJtaW5hbCksCi07OyAgIGdyYWJiZXIgaXMgYSBzdHJpbmcgKGVp dGhlciAiPCIsICI8LSIgb3IgIjwtLSIpLCBhbmQKLTs7ICAgcGF0dGVybiBpcyB0aGUgcGFy c2Ugb2YgYSBQRUcgcGF0dGVybiBleHByZXNzZWQgYXMgYXMgc3RyaW5nLgotKGRlZmluZSAo cGVnLW5vbnRlcm0tPmRlZm4gbHN0IGZvci1zeW50YXgpCi0gIChsZXQqICgobm9udGVybSAo Y2FyIGxzdCkpCi0gICAgICAgICAoZ3JhYmJlciAoY2FkciBsc3QpKQotICAgICAgICAgKHBh dHRlcm4gKGNhZGRyIGxzdCkpCi0gICAgICAgICAobm9udGVybS1uYW1lIChkYXR1bS0+c3lu dGF4IGZvci1zeW50YXgKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg KHN0cmluZy0+c3ltYm9sIChjYWRyIG5vbnRlcm0pKSkpKQotICAgICNgKGRlZmluZS1wZWct cGF0dGVybiAjLG5vbnRlcm0tbmFtZQotICAgICAgICMsKGNvbmQKLSAgICAgICAgICAoKHN0 cmluZz0/IGdyYWJiZXIgIjwtLSIpIChkYXR1bS0+c3ludGF4IGZvci1zeW50YXggJ2FsbCkp Ci0gICAgICAgICAgKChzdHJpbmc9PyBncmFiYmVyICI8LSIpIChkYXR1bS0+c3ludGF4IGZv ci1zeW50YXggJ2JvZHkpKQotICAgICAgICAgIChlbHNlIChkYXR1bS0+c3ludGF4IGZvci1z eW50YXggJ25vbmUpKSkKLSAgICAgICAjLChjb21wcmVzc29yIChwZWctcGF0dGVybi0+ZGVm biBwYXR0ZXJuIGZvci1zeW50YXgpIGZvci1zeW50YXgpKSkpCi0KLTs7IGxzdCBoYXMgZm9y bWF0ICgncGVnLXBhdHRlcm4gLi4uKS4KLTs7IEFmdGVyIHRoZSBjb250ZXh0LWZsYXR0ZW4s IChjZHIgbHN0KSBoYXMgZm9ybWF0Ci07OyAgICgoJ3BlZy1hbHRlcm5hdGl2ZSAuLi4pIC4u LiksIHdoZXJlIHRoZSBvdXRlciBsaXN0IGlzIGEgY29sbGVjdGlvbgotOzsgICBvZiBlbGVt ZW50cyBmcm9tIGEgJy8nIGFsdGVybmF0aXZlLgotKGRlZmluZSAocGVnLXBhdHRlcm4tPmRl Zm4gbHN0IGZvci1zeW50YXgpCi0gICNgKG9yICMsQChtYXAgKGxhbWJkYSAoeCkgKHBlZy1h bHRlcm5hdGl2ZS0+ZGVmbiB4IGZvci1zeW50YXgpKQotICAgICAgICAgICAgICAgIChjb250 ZXh0LWZsYXR0ZW4gKGxhbWJkYSAoeCkgKGVxPyAoY2FyIHgpICdwZWctYWx0ZXJuYXRpdmUp KQotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKGNkciBsc3QpKSkpKQotCi07 OyBsc3QgaGFzIGZvcm1hdCAoJ3BlZy1hbHRlcm5hdGl2ZSAuLi4pLgotOzsgQWZ0ZXIgdGhl IGNvbnRleHQtZmxhdHRlbiwgKGNkciBsc3QpIGhhcyB0aGUgZm9ybWF0Ci07OyAgIChpdGVt IC4uLiksIHdoZXJlIGVhY2ggaXRlbSBoYXMgZm9ybWF0IGVpdGhlciAoIiEiIC4uLiksICgi JiIgLi4uKSwKLTs7ICAgb3IgKCdwZWctc3VmZml4IC4uLikuCi0oZGVmaW5lIChwZWctYWx0 ZXJuYXRpdmUtPmRlZm4gbHN0IGZvci1zeW50YXgpCi0gICNgKGFuZCAjLEAobWFwIChsYW1i ZGEgKHgpIChwZWctYm9keS0+ZGVmbiB4IGZvci1zeW50YXgpKQotICAgICAgICAgICAgICAg ICAoY29udGV4dC1mbGF0dGVuIChsYW1iZGEgKHgpIChvciAoc3RyaW5nPyAoY2FyIHgpKQot ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKGVxPyAoY2Fy IHgpICdwZWctc3VmZml4KSkpCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg KGNkciBsc3QpKSkpKQotCi07OyBsc3QgaGFzIHRoZSBmb3JtYXQgZWl0aGVyCi07OyAgICgi ISIgKCdwZWctc3VmZml4IC4uLikpLCAoIiYiICgncGVnLXN1ZmZpeCAuLi4pKSwgb3IKLTs7 ICAgICAoJ3BlZy1zdWZmaXggLi4uKS4KLShkZWZpbmUgKHBlZy1ib2R5LT5kZWZuIGxzdCBm b3Itc3ludGF4KQotICAgIChjb25kCi0gICAgICAoKGVxdWFsPyAoY2FyIGxzdCkgIiYiKQot ICAgICAgICNgKGZvbGxvd2VkLWJ5ICMsKHBlZy1zdWZmaXgtPmRlZm4gKGNhZHIgbHN0KSBm b3Itc3ludGF4KSkpCi0gICAgICAoKGVxdWFsPyAoY2FyIGxzdCkgIiEiKQotICAgICAgICNg KG5vdC1mb2xsb3dlZC1ieSAjLChwZWctc3VmZml4LT5kZWZuIChjYWRyIGxzdCkgZm9yLXN5 bnRheCkpKQotICAgICAgKChlcT8gKGNhciBsc3QpICdwZWctc3VmZml4KQotICAgICAgIChw ZWctc3VmZml4LT5kZWZuIGxzdCBmb3Itc3ludGF4KSkKLSAgICAgIChlbHNlIGAocGVnLXBh cnNlLWJvZHktZmFpbCAsbHN0KSkpKQotCi07OyBsc3QgaGFzIGZvcm1hdCAoJ3BlZy1zdWZm aXggPHBlZy1wcmltYXJ5PiAoPyAoLyAiKiIgIj8iICIrIikpKQotKGRlZmluZSAocGVnLXN1 ZmZpeC0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKLSAgKGxldCAoKGlubmVyLWRlZm4gKHBlZy1w cmltYXJ5LT5kZWZuIChjYWRyIGxzdCkgZm9yLXN5bnRheCkpKQotICAgIChjb25kCi0gICAg ICAoKG51bGw/IChjZGRyIGxzdCkpCi0gICAgICAgaW5uZXItZGVmbikKLSAgICAgICgoZXF1 YWw/IChjYWRkciBsc3QpICIqIikKLSAgICAgICAjYCgqICMsaW5uZXItZGVmbikpCi0gICAg ICAoKGVxdWFsPyAoY2FkZHIgbHN0KSAiPyIpCi0gICAgICAgI2AoPyAjLGlubmVyLWRlZm4p KQotICAgICAgKChlcXVhbD8gKGNhZGRyIGxzdCkgIisiKQotICAgICAgICNgKCsgIyxpbm5l ci1kZWZuKSkpKSkKLQotOzsgUGFyc2UgYSBwcmltYXJ5LgotKGRlZmluZSAocGVnLXByaW1h cnktPmRlZm4gbHN0IGZvci1zeW50YXgpCi0gIChsZXQgKChlbCAoY2FkciBsc3QpKSkKLSAg KGNvbmQKLSAgICgobGlzdD8gZWwpCi0gICAgKGNvbmQKLSAgICAgKChlcT8gKGNhciBlbCkg J3BlZy1saXRlcmFsKQotICAgICAgKHBlZy1saXRlcmFsLT5kZWZuIGVsIGZvci1zeW50YXgp KQotICAgICAoKGVxPyAoY2FyIGVsKSAncGVnLWNoYXJjbGFzcykKLSAgICAgIChwZWctY2hh cmNsYXNzLT5kZWZuIGVsIGZvci1zeW50YXgpKQotICAgICAoKGVxPyAoY2FyIGVsKSAncGVn LW5vbnRlcm1pbmFsKQotICAgICAgKGRhdHVtLT5zeW50YXggZm9yLXN5bnRheCAoc3RyaW5n LT5zeW1ib2wgKGNhZHIgZWwpKSkpKSkKLSAgICgoc3RyaW5nPyBlbCkKLSAgICAoY29uZAot ICAgICAoKGVxdWFsPyBlbCAiKCIpCi0gICAgICAocGVnLXBhdHRlcm4tPmRlZm4gKGNhZGRy IGxzdCkgZm9yLXN5bnRheCkpCi0gICAgICgoZXF1YWw/IGVsICIuIikKLSAgICAgIChkYXR1 bS0+c3ludGF4IGZvci1zeW50YXggJ3BlZy1hbnkpKQotICAgICAoZWxzZSAoZGF0dW0tPnN5 bnRheCBmb3Itc3ludGF4Ci0gICAgICAgICAgICAgICAgICAgICAgICAgIGAocGVnLXBhcnNl LWFueSB1bmtub3duLXN0cmluZyAsbHN0KSkpKSkKLSAgIChlbHNlIChkYXR1bS0+c3ludGF4 IGZvci1zeW50YXgKLSAgICAgICAgICAgICAgICAgICAgICAgIGAocGVnLXBhcnNlLWFueSB1 bmtub3duLWVsICxsc3QpKSkpKSkKLQotOzsgVHJpbXMgY2hhcmFjdGVycyBvZmYgdGhlIGZy b250IGFuZCBlbmQgb2YgU1RSLgotOzsgKHRyaW0tMWNoYXJzICInYWInIikgLT4gImFiIgot KGRlZmluZSAodHJpbS0xY2hhcnMgc3RyKSAoc3Vic3RyaW5nIHN0ciAxICgtIChzdHJpbmct bGVuZ3RoIHN0cikgMSkpKQotCi07OyBQYXJzZXMgYSBsaXRlcmFsLgotKGRlZmluZSAocGVn LWxpdGVyYWwtPmRlZm4gbHN0IGZvci1zeW50YXgpCi0gIChkYXR1bS0+c3ludGF4IGZvci1z eW50YXggKHRyaW0tMWNoYXJzIChjYWRyIGxzdCkpKSkKLQotOzsgUGFyc2VzIGEgY2hhcmNs YXNzLgotKGRlZmluZSAocGVnLWNoYXJjbGFzcy0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKLSAg I2Aob3IKLSAgICAgIyxAKG1hcAotICAgICAgICAgKGxhbWJkYSAoY2MpCi0gICAgICAgICAg IChjb25kCi0gICAgICAgICAgICAoKGVxPyAoY2FyIGNjKSAnY2hhcmNsYXNzLXJhbmdlKQot ICAgICAgICAgICAgICNgKHJhbmdlICMsKGRhdHVtLT5zeW50YXgKLSAgICAgICAgICAgICAg ICAgICAgICAgICBmb3Itc3ludGF4Ci0gICAgICAgICAgICAgICAgICAgICAgICAgKHN0cmlu Zy1yZWYgKGNhZHIgY2MpIDApKQotICAgICAgICAgICAgICAgICAgICAgICMsKGRhdHVtLT5z eW50YXgKLSAgICAgICAgICAgICAgICAgICAgICAgICBmb3Itc3ludGF4Ci0gICAgICAgICAg ICAgICAgICAgICAgICAgKHN0cmluZy1yZWYgKGNhZHIgY2MpIDIpKSkpCi0gICAgICAgICAg ICAoKGVxPyAoY2FyIGNjKSAnY2hhcmNsYXNzLXNpbmdsZSkKLSAgICAgICAgICAgICAoZGF0 dW0tPnN5bnRheCBmb3Itc3ludGF4IChjYWRyIGNjKSkpKSkKLSAgICAgICAgIChjb250ZXh0 LWZsYXR0ZW4KLSAgICAgICAgICAobGFtYmRhICh4KSAob3IgKGVxPyAoY2FyIHgpICdjaGFy Y2xhc3MtcmFuZ2UpCi0gICAgICAgICAgICAgICAgICAgICAgICAgIChlcT8gKGNhciB4KSAn Y2hhcmNsYXNzLXNpbmdsZSkpKQotICAgICAgICAgIChjZHIgbHN0KSkpKSkKLQogOzsgQ29t cHJlc3NlcyBhIGxpc3QgdG8gc2F2ZSB0aGUgb3B0aW1pemVyIHdvcmsuCiA7OyBlLmcuIChv ciAoYW5kIGEpKSAtPiBhCiAoZGVmaW5lIChjb21wcmVzc29yLWNvcmUgbHN0KQpAQCAtMjYz LDExICszNDAsMTAgQEAgUkIgPCAnXScKICAgICAgKGxldCAoKHN0cmluZyAoc3ludGF4LT5k YXR1bSAjJ3N0ci1zdHgpKSkKICAgICAgICAoY29tcGlsZS1wZWctcGF0dGVybgogICAgICAg ICAoY29tcHJlc3NvcgotICAgICAgICAgKHBlZy1wYXR0ZXJuLT5kZWZuCi0gICAgICAgICAg KHBlZzp0cmVlIChtYXRjaC1wYXR0ZXJuIHBlZy1wYXR0ZXJuIHN0cmluZykpICMnc3RyLXN0 eCkKKyAgICAgICAgIChFeHByZXNzaW9uLT5kZWZuCisgICAgICAgICAgKHBlZzp0cmVlICht YXRjaC1wYXR0ZXJuIEV4cHJlc3Npb24gc3RyaW5nKSkgIydzdHItc3R4KQogICAgICAgICAg IydzdHItc3R4KQogICAgICAgICAoaWYgKGVxPyBhY2N1bSAnYWxsKSAnYm9keSBhY2N1bSkp KSkKICAgICAgKGVsc2UgKGVycm9yICJCYWQgZW1iZWRkZWQgUEVHIHN0cmluZyIgYXJncykp KSkKIAogKGFkZC1wZWctY29tcGlsZXIhICdwZWcgcGVnLXN0cmluZy1jb21waWxlKQotCmRp ZmYgLS1naXQgYS90ZXN0LXN1aXRlL3Rlc3RzL3BlZy50ZXN0IGIvdGVzdC1zdWl0ZS90ZXN0 cy9wZWcudGVzdAppbmRleCBmNTE2NTcxZTguLjU1NjE0NWU3MiAxMDA2NDQKLS0tIGEvdGVz dC1zdWl0ZS90ZXN0cy9wZWcudGVzdAorKysgYi90ZXN0LXN1aXRlL3Rlc3RzL3BlZy50ZXN0 CkBAIC0yOCwxNyArMjgsMjUgQEAKIDs7IHRoZSBub250ZXJtaW5hbHMgZGVmaW5lZCBpbiB0 aGUgUEVHIHBhcnNlciB3cml0dGVuIHdpdGgKIDs7IFMtZXhwcmVzc2lvbnMuCiAoZGVmaW5l IGdyYW1tYXItbWFwcGluZwotICAnKChncmFtbWFyIHBlZy1ncmFtbWFyKQotICAgIChwYXR0 ZXJuIHBlZy1wYXR0ZXJuKQotICAgIChhbHRlcm5hdGl2ZSBwZWctYWx0ZXJuYXRpdmUpCi0g ICAgKHN1ZmZpeCBwZWctc3VmZml4KQotICAgIChwcmltYXJ5IHBlZy1wcmltYXJ5KQotICAg IChsaXRlcmFsIHBlZy1saXRlcmFsKQotICAgIChjaGFyY2xhc3MgcGVnLWNoYXJjbGFzcykK LSAgICAoQ0NyYW5nZSBjaGFyY2xhc3MtcmFuZ2UpCi0gICAgKENDc2luZ2xlIGNoYXJjbGFz cy1zaW5nbGUpCi0gICAgKG5vbnRlcm1pbmFsIHBlZy1ub250ZXJtaW5hbCkKLSAgICAoc3Ag cGVnLXNwKSkpCisgICcoKEdyYW1tYXIgR3JhbW1hcikKKyAgICAoRGVmaW5pdGlvbiBEZWZp bml0aW9uKQorICAgIChFeHByZXNzaW9uIEV4cHJlc3Npb24pCisgICAgKFNlcXVlbmNlIFNl cXVlbmNlKQorICAgIChQcmVmaXggUHJlZml4KQorICAgIChTdWZmaXggU3VmZml4KQorICAg IChQcmltYXJ5IFByaW1hcnkpCisgICAgKElkZW50aWZpZXIgSWRlbnRpZmllcikKKyAgICAo TGl0ZXJhbCBMaXRlcmFsKQorICAgIChDbGFzcyBDbGFzcykKKyAgICAoUmFuZ2UgUmFuZ2Up CisgICAgKENoYXIgQ2hhcikKKyAgICAoTEVGVEFSUk9XIExFRlRBUlJPVykKKyAgICAoQU5E IEFORCkKKyAgICAoTk9UIE5PVCkKKyAgICAoUVVFU1RJT04gUVVFU1RJT04pCisgICAgKFNU QVIgU1RBUikKKyAgICAoUExVUyBQTFVTKQorICAgIChET1QgRE9UKSkpCiAKIDs7IFRyYW5z Zm9ybXMgdGhlIG5vbnRlcm1pbmFscyBkZWZpbmVkIGluIHRoZSBQRUcgcGFyc2VyIHdyaXR0 ZW4gYXMgYSBQRUcgdG8gdGhlIG5vbnRlcm1pbmFscyBkZWZpbmVkIGluIHRoZSBQRUcgcGFy c2VyIHdyaXR0ZW4gd2l0aCBTLWV4cHJlc3Npb25zLgogKGRlZmluZSAoZ3JhbW1hci10cmFu c2Zvcm0geCkKQEAgLTY5LDcgKzc3LDcgQEAKICAgICAocGVnOnRyZWUgKG1hdGNoLXBhdHRl cm4gKEBAIChpY2UtOSBwZWcpIHBlZy1ncmFtbWFyKSAoQEAgKGljZS05IHBlZykgcGVnLWFz LXBlZykpKQogICAgICh0cmVlLW1hcAogICAgICBncmFtbWFyLXRyYW5zZm9ybQotICAgICAo cGVnOnRyZWUgKG1hdGNoLXBhdHRlcm4gZ3JhbW1hciAoQEAgKGljZS05IHBlZykgcGVnLWFz LXBlZykpKSkpKSkKKyAgICAgKHBlZzp0cmVlIChtYXRjaC1wYXR0ZXJuIChAQCAoaWNlLTkg cGVnKSBwZWctZ3JhbW1hcikgKEBAIChpY2UtOSBwZWcpIHBlZy1hcy1wZWcpKSkpKSkpCiAK IDs7IEEgZ3JhbW1hciBmb3IgcGFzY2FsLXN0eWxlIGNvbW1lbnRzIGZyb20gV2lraXBlZGlh LgogKGRlZmluZSBjb21tZW50LWdyYW1tYXIKLS0gCjIuNDUuMgoK --------------K7qhRUZlD0lobVe4Y71Rz1L9-- From debbugs-submit-bounces@debbugs.gnu.org Thu Sep 12 16:58:20 2024 Received: (at 73188) by debbugs.gnu.org; 12 Sep 2024 20:58:21 +0000 Received: from localhost ([127.0.0.1]:42035 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1soqtP-0001DT-LI for submit@debbugs.gnu.org; Thu, 12 Sep 2024 16:58:20 -0400 Received: from dane.soverin.net ([185.233.34.25]:34529) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1soqtL-0001D7-JI for 73188@debbugs.gnu.org; Thu, 12 Sep 2024 16:58:18 -0400 Received: from smtp.soverin.net (unknown [10.10.4.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by dane.soverin.net (Postfix) with ESMTPS id 4X4VBw2FdKzygD; Thu, 12 Sep 2024 20:58:00 +0000 (UTC) Received: from smtp.soverin.net (smtp.soverin.net [10.10.4.100]) by soverin.net (Postfix) with ESMTPSA id 4X4VBv5RWGzHs; Thu, 12 Sep 2024 20:57:59 +0000 (UTC) Authentication-Results: smtp.soverin.net; dkim=pass (2048-bit key; unprotected) header.d=elenq.tech header.i=@elenq.tech header.a=rsa-sha256 header.s=soverin1 header.b=izV3fZ+4; dkim-atps=neutral DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=elenq.tech; s=soverin1; t=1726174680; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding; bh=9zK5c4hAzcscWmE1ntCTP3Y6yCNfUiC3RXy4qIkpNCQ=; b=izV3fZ+4jMKDvCjO1S5xMAZQ8PfDolcq8vTi+BxaOxeTE+pvzfh4HTky57DsGTaKTP65Vv nzEVGzDKwoPlC8/+uptehpMhTdM7Uw3g2f0FxYB62Wpqp53uBmj0peMK9ZmteuGTxrEnIY wJGIIUNrTZ2zdN6lLa3R+iVSOsRwIEq7Fx/rnb+wX9GAQuooS17KOqf7cBz7d5vV6nTtzJ fPmkeiyhYN7ZON4NJ/YscP5+tCG+OltyOG6ulQqNhA9VlPlIJ+MmyPPqmS6Sfc3gXDSnxV vNZYeQ9G6v+5cqVRcWq0F0lMLSQatf5XIRgdYoyHaJCWAQ1cCpaVU1lJ/rUE9w== From: Ekaitz Zarraga To: 73188@debbugs.gnu.org Subject: [PATCH v2] PEG: Add full support for PEG + some extensions Date: Thu, 12 Sep 2024 22:57:22 +0200 Message-ID: <20240912205751.23724-1-ekaitz@elenq.tech> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Spampanel-Class: ham X-Spam-Score: -0.7 (/) X-Debbugs-Envelope-To: 73188 Cc: Ekaitz Zarraga X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.7 (-) This commit adds support for PEG as described in: It adds support for the missing features (comments, underscores in identifiers and escaping) while keeping the extensions (dashes in identifiers, < and <--). The naming system tries to be as close as possible to the one proposed in the paper. * module/ice-9/peg/string-peg.scm: Rewrite PEG parser. * test-suite/tests/peg.test: Fix import --- Previus version did not make proper character and escaping control. module/ice-9/peg/string-peg.scm | 438 ++++++++++++++++++++------------ test-suite/tests/peg.test | 32 ++- 2 files changed, 292 insertions(+), 178 deletions(-) diff --git a/module/ice-9/peg/string-peg.scm b/module/ice-9/peg/string-peg.scm index 45ed14bb1..05755693a 100644 --- a/module/ice-9/peg/string-peg.scm +++ b/module/ice-9/peg/string-peg.scm @@ -1,6 +1,6 @@ ;;;; string-peg.scm --- representing PEG grammars as strings ;;;; -;;;; Copyright (C) 2010, 2011 Free Software Foundation, Inc. +;;;; Copyright (C) 2010, 2011, 2023 Free Software Foundation, Inc. ;;;; ;;;; This library is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Lesser General Public @@ -22,6 +22,7 @@ define-peg-string-patterns peg-grammar) #:use-module (ice-9 peg using-parsers) + #:use-module (srfi srfi-1) #:use-module (ice-9 peg codegen) #:use-module (ice-9 peg simplify-tree)) @@ -38,22 +39,57 @@ ;; Grammar for PEGs in PEG grammar. (define peg-as-peg -"grammar <-- (nonterminal ('<--' / '<-' / '<') sp pattern)+ -pattern <-- alternative (SLASH sp alternative)* -alternative <-- ([!&]? sp suffix)+ -suffix <-- primary ([*+?] sp)* -primary <-- '(' sp pattern ')' sp / '.' sp / literal / charclass / nonterminal !'<' -literal <-- ['] (!['] .)* ['] sp -charclass <-- LB (!']' (CCrange / CCsingle))* RB sp -CCrange <-- . '-' . -CCsingle <-- . -nonterminal <-- [a-zA-Z0-9-]+ sp -sp < [ \t\n]* -SLASH < '/' -LB < '[' -RB < ']' +"# Hierarchical syntax +Grammar <-- Spacing Definition+ EndOfFile +Definition <-- Identifier LEFTARROW Expression + +Expression <-- Sequence (SLASH Sequence)* +Sequence <-- Prefix* +Prefix <-- (AND / NOT)? Suffix +Suffix <-- Primary (QUESTION / STAR / PLUS)? +Primary <-- Identifier !LEFTARROW + / OPEN Expression CLOSE + / Literal / Class / DOT + +# Lexical syntax +Identifier <-- IdentStart IdentCont* Spacing +# NOTE: `-` is an extension +IdentStart <- [a-zA-Z_] / '-' +IdentCont <- IdentStart / [0-9] + +Literal <-- SQUOTE (!SQUOTE Char)* SQUOTE Spacing + / DQUOTE (!DQUOTE Char)* DQUOTE Spacing +Class <-- '[' (!']' Range)* ']' Spacing +Range <-- Char '-' Char / Char +Char <-- '\\\\' [nrt'\"\\[\\]\\\\] + / '\\\\' [0-7][0-7][0-7] + / '\\\\' [0-7][0-7]? + / !'\\\\' . + +# NOTE: `<--` and `<` are extensions +LEFTARROW <- ('<--' / '<-' / '<') Spacing +SQUOTE <-- ['] +DQUOTE <-- [\"] +OPENBRACKET < '[' +CLOSEBRACKET < ']' +SLASH < '/' Spacing +AND <-- '&' Spacing +NOT <-- '!' Spacing +QUESTION <-- '?' Spacing +STAR <-- '*' Spacing +PLUS <-- '+' Spacing +OPEN < '(' Spacing +CLOSE < ')' Spacing +DOT <-- '.' Spacing + +Spacing < (Space / Comment)* +Comment < '#' (!EndOfLine .)* EndOfLine +Space < ' ' / '\t' / EndOfLine +EndOfLine < '\\r\\n' / '\\n' / '\\r' +EndOfFile < !. ") + (define-syntax define-sexp-parser (lambda (x) (syntax-case x () @@ -63,35 +99,78 @@ RB < ']' (syn (wrap-parser-for-users x matchf accumsym #'sym))) #`(define sym #,syn)))))) -(define-sexp-parser peg-grammar all - (+ (and peg-nonterminal (or "<--" "<-" "<") peg-sp peg-pattern))) -(define-sexp-parser peg-pattern all - (and peg-alternative - (* (and (ignore "/") peg-sp peg-alternative)))) -(define-sexp-parser peg-alternative all - (+ (and (? (or "!" "&")) peg-sp peg-suffix))) -(define-sexp-parser peg-suffix all - (and peg-primary (* (and (or "*" "+" "?") peg-sp)))) -(define-sexp-parser peg-primary all - (or (and "(" peg-sp peg-pattern ")" peg-sp) - (and "." peg-sp) - peg-literal - peg-charclass - (and peg-nonterminal (not-followed-by "<")))) -(define-sexp-parser peg-literal all - (and "'" (* (and (not-followed-by "'") peg-any)) "'" peg-sp)) -(define-sexp-parser peg-charclass all - (and (ignore "[") - (* (and (not-followed-by "]") - (or charclass-range charclass-single))) - (ignore "]") - peg-sp)) -(define-sexp-parser charclass-range all (and peg-any "-" peg-any)) -(define-sexp-parser charclass-single all peg-any) -(define-sexp-parser peg-nonterminal all - (and (+ (or (range #\a #\z) (range #\A #\Z) (range #\0 #\9) "-")) peg-sp)) -(define-sexp-parser peg-sp none - (* (or " " "\t" "\n"))) +(define-sexp-parser Grammar all + (and Spacing (+ Definition) EndOfFile)) +(define-sexp-parser Definition all + (and Identifier LEFTARROW Expression)) +(define-sexp-parser Expression all + (and Sequence (* (and SLASH Sequence)))) +(define-sexp-parser Sequence all + (* Prefix)) +(define-sexp-parser Prefix all + (and (? (or AND NOT)) Suffix)) +(define-sexp-parser Suffix all + (and Primary (? (or QUESTION STAR PLUS)))) +(define-sexp-parser Primary all + (or (and Identifier (not-followed-by LEFTARROW)) + (and OPEN Expression CLOSE) + Literal + Class + DOT)) +(define-sexp-parser Identifier all + (and IdentStart (* IdentCont) Spacing)) +(define-sexp-parser IdentStart body + (or (range #\a #\z) (range #\A #\Z) "_" "-")) ; NOTE: - is an extension +(define-sexp-parser IdentCont body + (or IdentStart (range #\0 #\9))) +(define-sexp-parser Literal all + (or (and SQUOTE (* (and (not-followed-by SQUOTE) Char)) SQUOTE Spacing) + (and DQUOTE (* (and (not-followed-by DQUOTE) Char)) DQUOTE Spacing))) +(define-sexp-parser Class all + (and OPENBRACKET (* (and (not-followed-by CLOSEBRACKET) Range)) CLOSEBRACKET Spacing)) +(define-sexp-parser Range all + (or (and Char DASH Char) Char)) +(define-sexp-parser Char all + (or (and "\\" (or "n" "r" "t" "'" "[" "]" "\\")) + (and "\\" (range #\0 #\7) (range #\0 #\7) (range #\0 #\7)) + (and "\\" (range #\0 #\7) (? (range #\0 #\7))) + (and (not-followed-by "\\") peg-any))) +(define-sexp-parser LEFTARROW body + (and (or "<--" "<-" "<") Spacing)) ; NOTE: <-- and < are extensions +(define-sexp-parser SLASH none + (and "/" Spacing)) +(define-sexp-parser AND all + (and "&" Spacing)) +(define-sexp-parser NOT all + (and "!" Spacing)) +(define-sexp-parser QUESTION all + (and "?" Spacing)) +(define-sexp-parser STAR all + (and "*" Spacing)) +(define-sexp-parser PLUS all + (and "+" Spacing)) +(define-sexp-parser OPEN none + (and "(" Spacing)) +(define-sexp-parser CLOSE none + (and ")" Spacing)) +(define-sexp-parser DOT all + (and "." Spacing)) +(define-sexp-parser SQUOTE none "'") +(define-sexp-parser DQUOTE none "\"") +(define-sexp-parser OPENBRACKET none "[") +(define-sexp-parser CLOSEBRACKET none "]") +(define-sexp-parser DASH none "-") +(define-sexp-parser Spacing none + (* (or Space Comment))) +(define-sexp-parser Comment none + (and "#" (* (and (not-followed-by EndOfLine) peg-any)) EndOfLine)) +(define-sexp-parser Space none + (or " " "\t" EndOfLine)) +(define-sexp-parser EndOfLine none + (or "\r\n" "\n" "\r")) +(define-sexp-parser EndOfFile none + (not-followed-by peg-any)) + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;; PARSE STRING PEGS @@ -101,7 +180,7 @@ RB < ']' ;; will define all of the nonterminals in the grammar with equivalent ;; PEG s-expressions. (define (peg-parser str for-syntax) - (let ((parsed (match-pattern peg-grammar str))) + (let ((parsed (match-pattern Grammar str))) (if (not parsed) (begin ;; (display "Invalid PEG grammar!\n") @@ -110,132 +189,160 @@ RB < ']' (cond ((or (not (list? lst)) (null? lst)) lst) - ((eq? (car lst) 'peg-grammar) - #`(begin - #,@(map (lambda (x) (peg-nonterm->defn x for-syntax)) - (context-flatten (lambda (lst) (<= (depth lst) 2)) - (cdr lst)))))))))) + ((eq? (car lst) 'Grammar) + (Grammar->defn lst for-syntax))))))) -;; Macro wrapper for PEG-PARSER. Parses PEG grammars expressed as strings and -;; defines all the appropriate nonterminals. -(define-syntax define-peg-string-patterns - (lambda (x) - (syntax-case x () - ((_ str) - (peg-parser (syntax->datum #'str) x))))) +;; (Grammar (Definition ...) (Definition ...)) +(define (Grammar->defn lst for-syntax) + #`(begin + #,@(map (lambda (x) (Definition->defn x for-syntax)) + (context-flatten (lambda (lst) (<= (depth lst) 1)) + (cdr lst))))) -;; lst has format (nonterm grabber pattern), where -;; nonterm is a symbol (the name of the nonterminal), -;; grabber is a string (either "<", "<-" or "<--"), and -;; pattern is the parse of a PEG pattern expressed as as string. -(define (peg-nonterm->defn lst for-syntax) - (let* ((nonterm (car lst)) - (grabber (cadr lst)) - (pattern (caddr lst)) - (nonterm-name (datum->syntax for-syntax - (string->symbol (cadr nonterm))))) - #`(define-peg-pattern #,nonterm-name +;; (Definition (Identifier "Something") "<-" (Expression ...)) +;; `-> (define-peg-pattern Something 'all ...) +(define (Definition->defn lst for-syntax) + (let ((identifier (second (second lst))) + (grabber (third lst)) + (expression (fourth lst))) + #`(define-peg-pattern #,(datum->syntax for-syntax + (string->symbol identifier)) #,(cond ((string=? grabber "<--") (datum->syntax for-syntax 'all)) ((string=? grabber "<-") (datum->syntax for-syntax 'body)) (else (datum->syntax for-syntax 'none))) - #,(compressor (peg-pattern->defn pattern for-syntax) for-syntax)))) - -;; lst has format ('peg-pattern ...). -;; After the context-flatten, (cdr lst) has format -;; (('peg-alternative ...) ...), where the outer list is a collection -;; of elements from a '/' alternative. -(define (peg-pattern->defn lst for-syntax) - #`(or #,@(map (lambda (x) (peg-alternative->defn x for-syntax)) - (context-flatten (lambda (x) (eq? (car x) 'peg-alternative)) - (cdr lst))))) - -;; lst has format ('peg-alternative ...). -;; After the context-flatten, (cdr lst) has the format -;; (item ...), where each item has format either ("!" ...), ("&" ...), -;; or ('peg-suffix ...). -(define (peg-alternative->defn lst for-syntax) - #`(and #,@(map (lambda (x) (peg-body->defn x for-syntax)) - (context-flatten (lambda (x) (or (string? (car x)) - (eq? (car x) 'peg-suffix))) - (cdr lst))))) - -;; lst has the format either -;; ("!" ('peg-suffix ...)), ("&" ('peg-suffix ...)), or -;; ('peg-suffix ...). -(define (peg-body->defn lst for-syntax) - (cond - ((equal? (car lst) "&") - #`(followed-by #,(peg-suffix->defn (cadr lst) for-syntax))) - ((equal? (car lst) "!") - #`(not-followed-by #,(peg-suffix->defn (cadr lst) for-syntax))) - ((eq? (car lst) 'peg-suffix) - (peg-suffix->defn lst for-syntax)) - (else `(peg-parse-body-fail ,lst)))) - -;; lst has format ('peg-suffix (? (/ "*" "?" "+"))) -(define (peg-suffix->defn lst for-syntax) - (let ((inner-defn (peg-primary->defn (cadr lst) for-syntax))) - (cond - ((null? (cddr lst)) - inner-defn) - ((equal? (caddr lst) "*") - #`(* #,inner-defn)) - ((equal? (caddr lst) "?") - #`(? #,inner-defn)) - ((equal? (caddr lst) "+") - #`(+ #,inner-defn))))) - -;; Parse a primary. -(define (peg-primary->defn lst for-syntax) - (let ((el (cadr lst))) + #,(compressor (Expression->defn expression for-syntax) for-syntax)))) + +;; (Expression (Sequence X)) +;; `-> (X) +;; (Expression (Sequence X) (Sequence Y)) +;; `-> (or X Y) +;; (Expression (Sequence X) ((Sequence Y) (Sequence Z) ...)) +;; `-> (or X Y Z ...) +(define (Expression->defn lst for-syntax) + (let ((first-sequence (second lst)) + (rest (cddr lst))) + #`(or #,(Sequence->defn first-sequence for-syntax) + #,@(map (lambda (x) + (Sequence->defn x for-syntax)) + (keyword-flatten '(Sequence) rest))))) + + +(define (Sequence->defn lst for-syntax) + #`(and #,@(map (lambda (x) (Prefix->defn x for-syntax)) (cdr lst)))) + + +;; (Prefix (Suffix ...)) +;; `-> (...) +;; (Prefix (NOT "!") (Suffix ...)) +;; `-> (not-followed-by ...) +;; (Prefix (AND "&") (Suffix ...)) +;; `-> (followed-by ...) +(define (Prefix->defn lst for-syntax) + (let ((suffix (second lst))) + (case (car suffix) + ('AND #`(followed-by #,(Suffix->defn (third lst) for-syntax))) + ('NOT #`(not-followed-by #,(Suffix->defn (third lst) for-syntax))) + (else (Suffix->defn suffix for-syntax))))) + +;; (Suffix (Primary ...)) +;; `-> (...) +;; (Suffix (Primary ...) (STAR "*")) +;; `-> (* ...) +;; (Suffix (Primary ...) (QUESTION "?")) +;; `-> (? ...) +;; (Suffix (Primary ...) (PLUS "+")) +;; `-> (+ ...) +(define (Suffix->defn lst for-syntax) + (let* ((primary (second lst)) + (out (Primary->defn primary for-syntax)) + (extra (cddr lst))) + (if (null? extra) + out + (case (caar extra) + ('QUESTION #`(? #,out)) + ('STAR #`(* #,out)) + ('PLUS #`(+ #,out)))))) + +(define (Primary->defn lst for-syntax) + (let ((value (second lst))) + (case (car value) + ('DOT #'peg-any) + ('Identifier (Identifier->defn value for-syntax)) + ('Expression (Expression->defn value for-syntax)) + ('Literal (Literal->defn value for-syntax)) + ('Class (Class->defn value for-syntax))))) + +;; (Identifier "hello") +;; `-> hello +(define (Identifier->defn lst for-syntax) + (datum->syntax for-syntax (string->symbol (second lst)))) + +;; (Literal (Char "a") (Char "b") (Char "c")) +;; `-> "abc" +(define (Literal->defn lst for-syntax) + (apply string (map (lambda (x) (Char->defn x for-syntax)) (cdr lst)))) + +;; TODO: empty Class can happen: `[]`, but what does it represent? +;; (Class ...) +;; `-> (or ...) +(define (Class->defn lst for-syntax) + #`(or #,@(map (lambda (x) (Range->defn x for-syntax)) + (cdr lst)))) + +;; For one character: +;; (Range (Char "a")) +;; `-> "a" +;; Or for a range: +;; (Range (Char "a") (Char "b")) +;; `-> (range #\a #\b) +(define (Range->defn lst for-syntax) (cond - ((list? el) - (cond - ((eq? (car el) 'peg-literal) - (peg-literal->defn el for-syntax)) - ((eq? (car el) 'peg-charclass) - (peg-charclass->defn el for-syntax)) - ((eq? (car el) 'peg-nonterminal) - (datum->syntax for-syntax (string->symbol (cadr el)))))) - ((string? el) + ((= 2 (length lst)) + (second (second lst))) + ((= 3 (length lst)) + #`(range + #,(Char->defn (second lst) for-syntax) + #,(Char->defn (third lst) for-syntax))))) + +;; (Char "a") +;; `-> #\a +;; (Char "\\n") +;; `-> #\newline +;; (Char "\\135") +;; `-> #\] +(define (Char->defn lst for-syntax) + (let* ((charstr (second lst)) + (first (string-ref charstr 0))) (cond - ((equal? el "(") - (peg-pattern->defn (caddr lst) for-syntax)) - ((equal? el ".") - (datum->syntax for-syntax 'peg-any)) - (else (datum->syntax for-syntax - `(peg-parse-any unknown-string ,lst))))) - (else (datum->syntax for-syntax - `(peg-parse-any unknown-el ,lst)))))) - -;; Trims characters off the front and end of STR. -;; (trim-1chars "'ab'") -> "ab" -(define (trim-1chars str) (substring str 1 (- (string-length str) 1))) - -;; Parses a literal. -(define (peg-literal->defn lst for-syntax) - (datum->syntax for-syntax (trim-1chars (cadr lst)))) - -;; Parses a charclass. -(define (peg-charclass->defn lst for-syntax) - #`(or - #,@(map - (lambda (cc) - (cond - ((eq? (car cc) 'charclass-range) - #`(range #,(datum->syntax - for-syntax - (string-ref (cadr cc) 0)) - #,(datum->syntax - for-syntax - (string-ref (cadr cc) 2)))) - ((eq? (car cc) 'charclass-single) - (datum->syntax for-syntax (cadr cc))))) - (context-flatten - (lambda (x) (or (eq? (car x) 'charclass-range) - (eq? (car x) 'charclass-single))) - (cdr lst))))) + ((= 1 (string-length charstr)) first) + ((char-numeric? (string-ref charstr 1)) + (integer->char + (reduce + 0 + (map + (lambda (x y) + (* (- (char->integer x) (char->integer #\0)) y)) + (reverse (string->list charstr 1)) + '(1 8 64))))) + (else + (case (string-ref charstr 1) + ((#\n) #\newline) + ((#\r) #\return) + ((#\t) #\tab) + ((#\') #\') + ((#\]) #\]) + ((#\\) #\\) + ((#\[) #\[)))))) + +(define peg-grammar Grammar) + +;; Macro wrapper for PEG-PARSER. Parses PEG grammars expressed as strings and +;; defines all the appropriate nonterminals. +(define-syntax define-peg-string-patterns + (lambda (x) + (syntax-case x () + ((_ str) + (peg-parser (syntax->datum #'str) x))))) ;; Compresses a list to save the optimizer work. ;; e.g. (or (and a)) -> a @@ -263,11 +370,10 @@ RB < ']' (let ((string (syntax->datum #'str-stx))) (compile-peg-pattern (compressor - (peg-pattern->defn - (peg:tree (match-pattern peg-pattern string)) #'str-stx) + (Expression->defn + (peg:tree (match-pattern Expression string)) #'str-stx) #'str-stx) (if (eq? accum 'all) 'body accum)))) (else (error "Bad embedded PEG string" args)))) (add-peg-compiler! 'peg peg-string-compile) - diff --git a/test-suite/tests/peg.test b/test-suite/tests/peg.test index f516571e8..556145e72 100644 --- a/test-suite/tests/peg.test +++ b/test-suite/tests/peg.test @@ -28,17 +28,25 @@ ;; the nonterminals defined in the PEG parser written with ;; S-expressions. (define grammar-mapping - '((grammar peg-grammar) - (pattern peg-pattern) - (alternative peg-alternative) - (suffix peg-suffix) - (primary peg-primary) - (literal peg-literal) - (charclass peg-charclass) - (CCrange charclass-range) - (CCsingle charclass-single) - (nonterminal peg-nonterminal) - (sp peg-sp))) + '((Grammar Grammar) + (Definition Definition) + (Expression Expression) + (Sequence Sequence) + (Prefix Prefix) + (Suffix Suffix) + (Primary Primary) + (Identifier Identifier) + (Literal Literal) + (Class Class) + (Range Range) + (Char Char) + (LEFTARROW LEFTARROW) + (AND AND) + (NOT NOT) + (QUESTION QUESTION) + (STAR STAR) + (PLUS PLUS) + (DOT DOT))) ;; Transforms the nonterminals defined in the PEG parser written as a PEG to the nonterminals defined in the PEG parser written with S-expressions. (define (grammar-transform x) @@ -69,7 +77,7 @@ (peg:tree (match-pattern (@@ (ice-9 peg) peg-grammar) (@@ (ice-9 peg) peg-as-peg))) (tree-map grammar-transform - (peg:tree (match-pattern grammar (@@ (ice-9 peg) peg-as-peg))))))) + (peg:tree (match-pattern (@@ (ice-9 peg) peg-grammar) (@@ (ice-9 peg) peg-as-peg))))))) ;; A grammar for pascal-style comments from Wikipedia. (define comment-grammar -- 2.45.2 From debbugs-submit-bounces@debbugs.gnu.org Fri Oct 11 08:32:49 2024 Received: (at 73188) by debbugs.gnu.org; 11 Oct 2024 12:32:49 +0000 Received: from localhost ([127.0.0.1]:33719 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1szEp6-0007nH-Rw for submit@debbugs.gnu.org; Fri, 11 Oct 2024 08:32:49 -0400 Received: from dane.soverin.net ([185.233.34.31]:52029) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1szEp1-0007mw-Qy for 73188@debbugs.gnu.org; Fri, 11 Oct 2024 08:32:46 -0400 Received: from smtp.soverin.net (c04smtp-lb01.int.sover.in [10.10.4.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by dane.soverin.net (Postfix) with ESMTPS id 4XQ5bY3462z2xHh; Fri, 11 Oct 2024 12:31:53 +0000 (UTC) Received: from smtp.soverin.net (smtp.soverin.net [10.10.4.99]) by soverin.net (Postfix) with ESMTPSA id 4XQ5bX734Yz4p; Fri, 11 Oct 2024 12:31:52 +0000 (UTC) Authentication-Results: smtp.soverin.net; dkim=pass (2048-bit key; unprotected) header.d=elenq.tech header.i=@elenq.tech header.a=rsa-sha256 header.s=soverin1 header.b=khqdiUi3; dkim-atps=neutral DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=elenq.tech; s=soverin1; t=1728649913; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding; bh=vEnHMClZMvYKR6M0Hm2od5kFf+G8eZVbvSrIpUqQe4Y=; b=khqdiUi34ZHOjYyS2PIvRPS8qMZCr6sb5eD3rAh32exPLTnXOUxNva5kT0xIJcZCES7aU9 4VHq5i33vd29YZNPOm79AFp4AuHUWWoSu4rj0s0OHXaK59lunOlwazdbzIhJsjsxPyPVEs LyMF0WbkpRFIpNVt6mbi2xLmf7FodA2DVCH2G0sJX7noB+Q5d713jcBF3TsCMDIVXpTjbw obTOSQlIUme81nOhGo/lM1Dg93rKkS3hoNdHLuKih7/nZaMXGsTTQ3t5Xr68Xm95Q5hE01 B+3QEDhsu0nl3FWPpojWsZnxwqjDBu6pmEsia+LfXr/uMx8QbPYfcX48xT5j+Q== From: Ekaitz Zarraga To: 73188@debbugs.gnu.org Subject: [PATCH] PEG: Add support for `not-in-range` and [^...] Date: Fri, 11 Oct 2024 14:31:40 +0200 Message-ID: <20241011123145.7228-1-ekaitz@elenq.tech> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Spampanel-Class: ham X-Spam-Score: -0.7 (/) X-Debbugs-Envelope-To: 73188 Cc: Ekaitz Zarraga X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.7 (-) Modern PEG supports inversed class like `[^a-z]` that would get any character not in the `a-z` range. This commit adds support for that and also for a new `not-in-range` PEG pattern for scheme. * module/ice-9/peg/codegen.scm (cg-not-in-range): New function. * module/ice-9/peg/string-peg.scm: Add support for `[^...]` * test-suite/tests/peg.test: Test it. * doc/ref/api-peg.texi: Document accordingly. --- doc/ref/api-peg.texi | 8 +++++++ module/ice-9/peg/codegen.scm | 22 +++++++++++++++++++ module/ice-9/peg/string-peg.scm | 39 +++++++++++++++++++++++++++++---- test-suite/tests/peg.test | 6 ++++- 4 files changed, 70 insertions(+), 5 deletions(-) diff --git a/doc/ref/api-peg.texi b/doc/ref/api-peg.texi index d34ddc64c..f2707442c 100644 --- a/doc/ref/api-peg.texi +++ b/doc/ref/api-peg.texi @@ -143,6 +143,14 @@ Parses any character falling between @var{a} and @var{z}. @code{(range #\a #\z)} @end deftp +@deftp {PEG Pattern} {inversed range of characters} a z +Parses any character not falling between @var{a} and @var{z}. + +@code{"[^a-z]"} + +@code{(not-in-range #\a #\z)} +@end deftp + Example: @example diff --git a/module/ice-9/peg/codegen.scm b/module/ice-9/peg/codegen.scm index d80c3e849..82367ef55 100644 --- a/module/ice-9/peg/codegen.scm +++ b/module/ice-9/peg/codegen.scm @@ -140,6 +140,27 @@ return EXP." ((none) #`(list (1+ pos) '())) (else (error "bad accum" accum)))))))))) +;; Generates code for matching a range of characters not between start and end. +;; E.g.: (cg-not-in-range syntax #\a #\z 'body) +(define (cg-not-in-range pat accum) + (syntax-case pat () + ((start end) + (if (not (and (char? (syntax->datum #'start)) + (char? (syntax->datum #'end)))) + (error "range PEG should have characters after it; instead got" + #'start #'end)) + #`(lambda (str len pos) + (and (< pos len) + (let ((c (string-ref str pos))) + (and (or (char? c end)) + #,(case accum + ((all) #`(list (1+ pos) + (list 'cg-not-in-range (string c)))) + ((name) #`(list (1+ pos) 'cg-not-in-range)) + ((body) #`(list (1+ pos) (string c))) + ((none) #`(list (1+ pos) '())) + (else (error "bad accum" accum)))))))))) + ;; Generate code to match a pattern and do nothing with the result (define (cg-ignore pat accum) (syntax-case pat () @@ -304,6 +325,7 @@ return EXP." (assq-set! peg-compiler-alist symbol function))) (add-peg-compiler! 'range cg-range) +(add-peg-compiler! 'not-in-range cg-not-in-range) (add-peg-compiler! 'ignore cg-ignore) (add-peg-compiler! 'capture cg-capture) (add-peg-compiler! 'and cg-and) diff --git a/module/ice-9/peg/string-peg.scm b/module/ice-9/peg/string-peg.scm index 05755693a..f88d2f7d8 100644 --- a/module/ice-9/peg/string-peg.scm +++ b/module/ice-9/peg/string-peg.scm @@ -49,7 +49,7 @@ Prefix <-- (AND / NOT)? Suffix Suffix <-- Primary (QUESTION / STAR / PLUS)? Primary <-- Identifier !LEFTARROW / OPEN Expression CLOSE - / Literal / Class / DOT + / Literal / Class / NotInClass / DOT # Lexical syntax Identifier <-- IdentStart IdentCont* Spacing @@ -59,7 +59,8 @@ IdentCont <- IdentStart / [0-9] Literal <-- SQUOTE (!SQUOTE Char)* SQUOTE Spacing / DQUOTE (!DQUOTE Char)* DQUOTE Spacing -Class <-- '[' (!']' Range)* ']' Spacing +NotInClass <-- '[' NOTIN (!']' Range)* ']' Spacing +Class <-- '[' !NOTIN (!']' Range)* ']' Spacing Range <-- Char '-' Char / Char Char <-- '\\\\' [nrt'\"\\[\\]\\\\] / '\\\\' [0-7][0-7][0-7] @@ -72,6 +73,7 @@ SQUOTE <-- ['] DQUOTE <-- [\"] OPENBRACKET < '[' CLOSEBRACKET < ']' +NOTIN < '^' SLASH < '/' Spacing AND <-- '&' Spacing NOT <-- '!' Spacing @@ -116,6 +118,7 @@ EndOfFile < !. (and OPEN Expression CLOSE) Literal Class + NotInClass DOT)) (define-sexp-parser Identifier all (and IdentStart (* IdentCont) Spacing)) @@ -127,7 +130,11 @@ EndOfFile < !. (or (and SQUOTE (* (and (not-followed-by SQUOTE) Char)) SQUOTE Spacing) (and DQUOTE (* (and (not-followed-by DQUOTE) Char)) DQUOTE Spacing))) (define-sexp-parser Class all - (and OPENBRACKET (* (and (not-followed-by CLOSEBRACKET) Range)) CLOSEBRACKET Spacing)) + (and OPENBRACKET (not-followed-by NOTIN) + (* (and (not-followed-by CLOSEBRACKET) Range)) CLOSEBRACKET Spacing)) +(define-sexp-parser NotInClass all + (and OPENBRACKET NOTIN + (* (and (not-followed-by CLOSEBRACKET) Range)) CLOSEBRACKET Spacing)) (define-sexp-parser Range all (or (and Char DASH Char) Char)) (define-sexp-parser Char all @@ -137,6 +144,8 @@ EndOfFile < !. (and (not-followed-by "\\") peg-any))) (define-sexp-parser LEFTARROW body (and (or "<--" "<-" "<") Spacing)) ; NOTE: <-- and < are extensions +(define-sexp-parser NOTIN none + (and "^")) (define-sexp-parser SLASH none (and "/" Spacing)) (define-sexp-parser AND all @@ -271,6 +280,7 @@ EndOfFile < !. ('Identifier (Identifier->defn value for-syntax)) ('Expression (Expression->defn value for-syntax)) ('Literal (Literal->defn value for-syntax)) + ('NotInClass (NotInClass->defn value for-syntax)) ('Class (Class->defn value for-syntax))))) ;; (Identifier "hello") @@ -283,13 +293,34 @@ EndOfFile < !. (define (Literal->defn lst for-syntax) (apply string (map (lambda (x) (Char->defn x for-syntax)) (cdr lst)))) -;; TODO: empty Class can happen: `[]`, but what does it represent? +;; (NotInClass ...) +;; `-> (and ...) +(define (NotInClass->defn lst for-syntax) + #`(and #,@(map (lambda (x) (NotInRange->defn x for-syntax)) + (cdr lst)))) + ;; (Class ...) ;; `-> (or ...) (define (Class->defn lst for-syntax) #`(or #,@(map (lambda (x) (Range->defn x for-syntax)) (cdr lst)))) +;; For one character: +;; (NotInRange (Char "a")) +;; `-> (not-in-range #\a #\a) +;; Or for a range: +;; (NotInRange (Char "a") (Char "b")) +;; `-> (not-in-range #\a #\b) +(define (NotInRange->defn lst for-syntax) + (cond + ((= 2 (length lst)) + (let ((ch (Char->defn (second lst) for-syntax))) + #`(not-in-range #,ch #,ch))) + ((= 3 (length lst)) + #`(not-in-range + #,(Char->defn (second lst) for-syntax) + #,(Char->defn (third lst) for-syntax))))) + ;; For one character: ;; (Range (Char "a")) ;; `-> "a" diff --git a/test-suite/tests/peg.test b/test-suite/tests/peg.test index 556145e72..965e1c12f 100644 --- a/test-suite/tests/peg.test +++ b/test-suite/tests/peg.test @@ -38,6 +38,7 @@ (Identifier Identifier) (Literal Literal) (Class Class) + (NotInClass NotInClass) (Range Range) (Char Char) (LEFTARROW LEFTARROW) @@ -85,7 +86,7 @@ End <-- '*)' C <- Begin N* End N <- C / (!Begin !End Z) -Z <- .") +Z <- [^X-Z]") ;; Forbid some characters to test not-in-range ;; A short /etc/passwd file. (define *etc-passwd* @@ -125,6 +126,9 @@ SLASH < '/'") (match-pattern C "(*blah*)") (make-prec 0 8 "(*blah*)" '((Begin "(*") "blah" (End "*)"))))) + (pass-if + "simple comment with forbidden char" + (not (match-pattern C "(*blYh*)"))) (pass-if "simple comment padded" (equal? -- 2.46.0 From debbugs-submit-bounces@debbugs.gnu.org Sun Oct 13 16:30:08 2024 Received: (at 73188) by debbugs.gnu.org; 13 Oct 2024 20:30:09 +0000 Received: from localhost ([127.0.0.1]:57174 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1t05E8-0002gX-GP for submit@debbugs.gnu.org; Sun, 13 Oct 2024 16:30:08 -0400 Received: from eggs.gnu.org ([209.51.188.92]:51392) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1t05E5-0002fX-NK for 73188@debbugs.gnu.org; Sun, 13 Oct 2024 16:30:07 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1t05Dj-00079r-Lk; Sun, 13 Oct 2024 16:29:43 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnu.org; s=fencepost-gnu-org; h=MIME-Version:Date:References:In-Reply-To:Subject:To: From; bh=Axe95t4auGGF9yTRfaBhD/l37ur1/JaoeIpB9MEfxF0=; b=mnCgriFnU55qJS1bK77b igSmogi1ONZ5YEikPrO6e1tt1jB76hfdSTn7wkFuTRs0hYl1F3WSK80W+RIgDJ/wzYfXhGFqVJt50 VMnywdvzViZh7r1bRzR43okGuDAa9norH3eW6uDReEuUm+4kgOzEraRC485otqsbH9jwaEant8Asp gH9B1Q86S069ugpkZyPfQqmJsjbrrLutzHgR2RH1pYz5CrNCs9bNIpva6GdfxNtIWnd8u5qXINoa/ LiK/cQWajBMseBveBEVIoYU+rQGsdaC8fsZBx0G7UizjyVa/cHSyaWmGuhl4hIujK2w/6UKvbx/5X 9knvOhXwcqed/w==; From: =?utf-8?Q?Ludovic_Court=C3=A8s?= To: Ekaitz Zarraga Subject: Re: bug#73188: PEG parser does not support full PEG grammar In-Reply-To: <20240912205751.23724-1-ekaitz@elenq.tech> (Ekaitz Zarraga's message of "Thu, 12 Sep 2024 22:57:22 +0200") References: <78a81bc5-cd0d-0506-185b-c733c66e96ae@elenq.tech> <20240912205751.23724-1-ekaitz@elenq.tech> Date: Sun, 13 Oct 2024 22:29:39 +0200 Message-ID: <87cyk3rbkc.fsf_-_@gnu.org> User-Agent: Gnus/5.13 (Gnus v5.13) MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 73188 Cc: 73188@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) Hi Ekaitz, Ekaitz Zarraga skribis: > This commit adds support for PEG as described in: > > I would make this a comment below the =E2=80=98define-module=E2=80=99 form. > It adds support for the missing features (comments, underscores in > identifiers and escaping) while keeping the extensions (dashes in > identifiers, < and <--). > > The naming system tries to be as close as possible to the one proposed > in the paper. > > * module/ice-9/peg/string-peg.scm: Rewrite PEG parser. > * test-suite/tests/peg.test: Fix import Nice work! Questions: 1. Is the name change for lexical elements (camel case instead of lower-case + hyphens) user-visible? I guess no but better be safe than sorry. I have a preference for lower-case + hyphens out of consistency with the rest of Scheme, but I can see how keeping the same names as in the reference material helps. 2. Could you add tests for the missing features that this adds, and maybe extend =E2=80=98api-peg.texi=E2=80=99 accordingly too? 3. You can choose to assign copyright to the FSF or to not do that=C2=B9. In the latter case, please add a copyright line for you where appropriate. I=E2=80=99m really not a PEG expert though so I=E2=80=99d prefer more eyeba= lls here, but I trust your judgment. There are three (guix import *) modules that use (ice-9 peg) and that come with tests. It would be nice to check that those tests still pass with the modified string-peg.scm. Thanks! Ludo=E2=80=99. =C2=B9 https://lists.gnu.org/archive/html/guile-devel/2022-10/msg00008.html From debbugs-submit-bounces@debbugs.gnu.org Sun Oct 13 17:00:18 2024 Received: (at 73188) by debbugs.gnu.org; 13 Oct 2024 21:00:18 +0000 Received: from localhost ([127.0.0.1]:57974 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1t05hJ-0004z3-Qi for submit@debbugs.gnu.org; Sun, 13 Oct 2024 17:00:18 -0400 Received: from dane.soverin.net ([185.233.34.30]:51501) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1t05hH-0004yi-GQ for 73188@debbugs.gnu.org; Sun, 13 Oct 2024 17:00:16 -0400 Received: from smtp.soverin.net (unknown [10.10.4.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by dane.soverin.net (Postfix) with ESMTPS id 4XRXmB6jzZz2xcJ; Sun, 13 Oct 2024 20:59:22 +0000 (UTC) Received: from smtp.soverin.net (smtp.soverin.net [10.10.4.100]) by soverin.net (Postfix) with ESMTPSA id 4XRXmB3nH9z1d; Sun, 13 Oct 2024 20:59:22 +0000 (UTC) Authentication-Results: smtp.soverin.net; dkim=pass (2048-bit key; unprotected) header.d=elenq.tech header.i=@elenq.tech header.a=rsa-sha256 header.s=soverin1 header.b=WpOe1O5n; dkim-atps=neutral DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=elenq.tech; s=soverin1; t=1728853162; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:autocrypt:autocrypt; bh=Bcm411rC54UNv8+897ijcjBQ6suMmTV9KKzAHcH7vCA=; b=WpOe1O5n6k3GkHboKnKbZNanbU8tXndfkctDc05TfKZVGj3NXITDAjrWjHBad3eY8/4x60 t182g0XXXzJiFUvMacvz0pAJZpDphTAIrC3z0AXqxqSH1q/AUlU/jYDgjwDDDWY8bMwV/7 vo9+WZ5Z0wpxPsd0kJohACWDefmGUS4rixQjN2ShJuCP/PTYANaAT5hcFqQ7hJTIKCE3XE wLY7c75e3ozgULuVmOCTTltAWXLdBJaaXiPMVVsnWjmF/Dtj+F8zNvdWdIooZ82jmSrpf1 BhazDunfeF2Pm0NqVC4ZeJMWiF4DeChuga40X8DHRHJEThGrtjEK4X/wTE/OGw== Message-ID: <168e01eb-ac58-4d39-a960-46624e65edde@elenq.tech> Date: Sun, 13 Oct 2024 22:59:22 +0200 MIME-Version: 1.0 Subject: Re: bug#73188: PEG parser does not support full PEG grammar To: =?UTF-8?Q?Ludovic_Court=C3=A8s?= References: <78a81bc5-cd0d-0506-185b-c733c66e96ae@elenq.tech> <20240912205751.23724-1-ekaitz@elenq.tech> <87cyk3rbkc.fsf_-_@gnu.org> Content-Language: en-US, es-ES, eu From: Ekaitz Zarraga Autocrypt: addr=ekaitz@elenq.tech; keydata= xsFNBGViSyIBEADY3g71uW/0CVaVm5/ObqTicQXXJRuh1uafIFiUUZoAp1V3V89b3LZ/m0cL 8YNHxTxsx8sKIMYTGlOvARAMiSpDvkmpf5pLn5T7+VvK90FOv/Pkp1tNNT+tvd0m/7C58+39 s7tN+XppbjVRtFuSXY0aFe8rpivZsKxv+tPUHUnQQszXvwgx0GQl8AX99IE+j75NJmBHFVg2 0geKa7QVymu669ix2+zU8vGoOKf5nIS0qG1m/vrtwR3ZuuyWX9/E/uP95ahX5ETWtjhTDbEm MEaRperwbczBewkdERJ34vRrverqKQA1xHXoPsx4NkLMocORFSSCJsveXcgWlU+pUIOYcKUA ARJjHhoWoUH4LZt5EOb7U17AaYMmATUXPCqq8G3jEXq6i0O1J1obCJGIRG02R9GiGp4zrVuv 2hmyoAmed4xYZAtf9WjcbwiunDkMGIxscdSlfEH/9dt7PGdEvkZ0dNSCTbp4ctMI4jAfobAL LReMSGx1CgPi01J61a/n/SgR66AiRJZCyC1u2V7AK1rBOAYzOU4UoePz+yF1I7crjZWAQVo6 DlmmXW+29l/lh2oK5jOuNEcvI6qi+tPCYxpDhUhZeYgqFU+/xgGlMj/XGvwuIFlpVg9ovFMg 6mxskOCVP9xNEp/qHiHqByYu5NRcITo/z/3BUimdXTT4KSq2cQARAQABzSJFa2FpdHogWmFy cmFnYSA8ZWthaXR6QGVsZW5xLnRlY2g+wsGOBBMBCAA4FiEEg/pnRVjAUpRlfkwZt5lM+Jly CyYFAmViSyICGwMFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQt5lM+JlyCybjZxAAy+YW 3Q22xKoMWJYw03qGCy87WPK+xGWDpKD6TJ77+/IEbldObyQRrKYTTGjQSy6WgaJ0txJMIqeK JyuWuR3bq+Vkh86Byntl25jknOJ+jY1zwPs6HnWFr+hS48FcQh/0D26h57Cqc+6nbKhJcva8 JsInbHTbWPz7wye+xhqY1LfdgVTbCyADESXdmBY30/vP4LzqW81atwYF6X7dN7ko/JvyPPdv VlcspmbP6zNihoApBHdMfJwYscyAsu6tTyL4hMG3zpraeU+S857vZN39gFagRng+uyZG7rfB dHHAFzT1LKOZ4dahavOfA0gS1RZTgtAGsvhUEBn9vKxlB4efZuKhwMtgQEskRFD6JIF1DYCj pLgn5x/y3oI6rn35R46VDhLfohcUWpvzplu6LBft8ZNr+UgoVYc6qBezyDlxk0FmhGI7DEoh gfUxljTALXjSdUGEw2mvp/Mcrz+ffemWpG4+Zq0UXR8sZaHpv+PqmFLFFSQCOCRTYbMKzZBn y03wym3y0tGtunDGm5pR7NEPqUO9QbZdKyTy4ftRkSfTpiPCF8+KKYDT8HimSrusmtTfR4R1 nBJ4lNBYgTdOyJYFbHdF0Jxo9r0t+K2e+6hX6bK79o6aC+/LtzkoYgjCWvAEopO0ras/XQYM S7/bCzeDIhXX5RqmMIp5XN+oBP2roZDOwU0EZWJLIgEQAMIgPDpJY9aOhFiFICx58XMM28An yUPdN39t0A8VkUbsvKXH6eNqUZj/Q3yNcZrknAT1vinv9FN/4uCUnsaqEKp+mRAYgzmNfeJk SWuMzmA04fcISIBz3sJUR0w/59tWi8QxlNn7IR6McAA3lHDXC+KYh9ZfhaOARfan1M6Ppy6g YltUQGSSPXU807inmQZh8GFTi8iUza7vGuBEnaNRGhmhR+blMwHSqVWN4gD81e8dSAEi3zNR sLoBXneHUqTcJMHvsT5cOk7cGMoVAWIffA2EKWfrgda57Qw+w+0OPqWEfKoXwnyt35Tl+Lxl 7MAaAG9R5760yhgkf3LmnBNP3m6StZ8Fv09Gdn5cGSbVnoofHDkg4PQDTD6aGz9af3SnGVg9 nb1Zm1XbqtnYwG9JvQhcjgWAHwrPLkHAcvKtfYWNe4wiirMjXMXxADY08g33SEchPJR2r4pg wttJS4kHUJ2IQUmSH/43RO5PkftWsCucYGeaG1aPr+GAkeKIS1M3OZGuqhd800mltpiH73eL XrUPF8fgngC+SGMrHXLfzuhaRxPNYUbsdF+wRkvjRSO4tCmSVpgfPsHu5emoZgix1iiTO7GF do7L6n1Ay3oF4Witoxc0Gcbu7ltYlZHGmDnsVTVALartsJV2muSXpWcjQiXyC0gUkIkUD/3P jtgVxK8xABEBAAHCwXYEGAEIACAWIQSD+mdFWMBSlGV+TBm3mUz4mXILJgUCZWJLIgIbDAAK CRC3mUz4mXILJrIaD/9CXGckwRCojuRzP0r6+8/RvNDc03CSe2W17WrSaoYgiRb+h5asI/AL yqw+QRgwXZpt0i9hNiDCe/baD62mufIyjKFjHoAWSYJuZ5VK3vWnro6GaxWULYt1+c4c4Lz2 d1nSK6j8F3CxYo7BFk6afOusjYfh+0HywThcYY+x+K5Z+4SdJejDLiL5AzJn2W5Gt/ViK5nI wl7uRQpayMc9zmI8ytUT2NJxovq1/fT9nB8VPwlbJTE9zvIqfqHh9o9Apx5o8yTaSCyGUyu9 8h/klqxFy4HAPJJu/3JkiMaCI45ZdCqRR1LIwhtmW2lb73r0rP/0S1cKi+ehA4oQvwiUw7zh XXw7mqzSAJ0SWT92Vy2G8Z8qqgwxwfQcdFZAyJAL1rgEPQljNT91Vgbc6DCUka2XW5BqyhEB eS0n1gK0hYXbM9FKegRsZxlmRAXa4KGXCwr4BNK6k+zkKPitezjbtcLgcKSHa8/HyHNkW7xH R+MN16x2elQPmQ2d0Ien1HgsK98+3prlUGwZIVCqa1ddSoW0llU3JzGsKrMAiYbWg/rOXFil RJbuhjflaLBVmfI8VlRQRocP+WEH0lsUWrtjVaGcBj1/YnIoT+zT6fPSXwPsrBvAWEjfl8HH e1F4cYb+ugPDwUTd1s2Uj2tF0/fhCHPy9sXyx/EIL3gqyBw9M2Rz9A== In-Reply-To: <87cyk3rbkc.fsf_-_@gnu.org> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit X-Spampanel-Class: ham X-Spam-Score: -0.7 (/) X-Debbugs-Envelope-To: 73188 Cc: 73188@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.7 (-) Saluton Ludovic, On 2024-10-13 22:29, Ludovic Courtès wrote: > Hi Ekaitz, > > Ekaitz Zarraga skribis: > >> This commit adds support for PEG as described in: >> >> > > I would make this a comment below the ‘define-module’ form. Okay I will add it. >> It adds support for the missing features (comments, underscores in >> identifiers and escaping) while keeping the extensions (dashes in >> identifiers, < and <--). >> >> The naming system tries to be as close as possible to the one proposed >> in the paper. >> >> * module/ice-9/peg/string-peg.scm: Rewrite PEG parser. >> * test-suite/tests/peg.test: Fix import > > Nice work! Thank you > Questions: > > 1. Is the name change for lexical elements (camel case instead of > lower-case + hyphens) user-visible? I guess no but better be safe > than sorry. I think they can be, in a very weird way. If using `peg-as-peg` or something they can be used, but the ones coming from the PEG in text, which makes way more sense written like in the paper. I'm not sure if there's another way to make them available, but I don't think there is. I exported `Grammar` as `peg-grammar` because of this. So the users should just use `peg-grammar` for their things. > I have a preference for lower-case + hyphens out of consistency > with the rest of Scheme, but I can see how keeping the same names > as in the reference material helps. Yeah, I wasn't sure about it. And I'm still not very sure. But I think keeping the same names the paper does helps. > 2. Could you add tests for the missing features that this adds, and > maybe extend ‘api-peg.texi’ accordingly too? It doesn't really add much new in this first case, but it makes it work as expected in PEG, which is what documentation already claimed to do, and the code didn't actually implement. Mostly what this commit adds is escaping support in the PEG string literals. > 3. You can choose to assign copyright to the FSF or to not do that¹. > In the latter case, please add a copyright line for you where > appropriate. I don't care (maybe I should?). I just want this to work properly. > I’m really not a PEG expert though so I’d prefer more eyeballs here, but > I trust your judgment. I don't know how wise this is :) > There are three (guix import *) modules that use (ice-9 peg) and that > come with tests. It would be nice to check that those tests still pass > with the modified string-peg.scm. This is very interesting and I didn't know. All tests from Guile pass, but I'll try these and report here. > Thanks! > > Ludo’. > > ¹ https://lists.gnu.org/archive/html/guile-devel/2022-10/msg00008.html Thanks for the review, Ludo. Next days I plan to review some older patches in the mailing list that offer a very straightforward solution for error reporting and try to include them with this and the extra features I added. For the time being, I'll review what you mentioned, rebase the support for `[^...]` and resend them together. I appreciate your time spent here, Ludo. Really. From debbugs-submit-bounces@debbugs.gnu.org Mon Oct 14 08:40:21 2024 Received: (at 73188) by debbugs.gnu.org; 14 Oct 2024 12:40:21 +0000 Received: from localhost ([127.0.0.1]:37031 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1t0KN3-0008OI-49 for submit@debbugs.gnu.org; Mon, 14 Oct 2024 08:40:21 -0400 Received: from eggs.gnu.org ([209.51.188.92]:57660) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1t0Jgc-0004th-Bq for 73188@debbugs.gnu.org; Mon, 14 Oct 2024 07:56:31 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1t0JgF-0006Tb-6W; Mon, 14 Oct 2024 07:56:07 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnu.org; s=fencepost-gnu-org; h=MIME-Version:Date:References:In-Reply-To:Subject:To: From; bh=I+mKB1ktfU3wo7pvr9Jtb1dS3j8qTIRsbQUOYXLAsdI=; b=p6gyjujVl5MbZgJkN8JQ Y3u+qEchHMlHXGf6vAoWUpUJ9Xr+ZwQ/vRMs8j4c1dOoEu57RSyGk7Wps3mpo6ysbV/8KW4Az9tBb 2hQG10WPBp2yfvKlXszdRBkABoQkMT/7KExZom2jjr7/76RvjmF7ItUKc66CJfDKTqQxD+EctEAGc 6SpI4MwvUQKgFqSzbfEAyAqxAMXNajQ/tBFXh+E7su92LWkBmFs3NfzHX84Q0ON8BV8txLPML4P0a 8lzCTyOsf47UPi7mewLySZlu8usmi2k3FlOibDbEEa7XXbZV/UKcdgqIYr6wCctb/X5vcInW2mX1m WdGDjfO7H8YLng==; From: =?utf-8?Q?Ludovic_Court=C3=A8s?= To: Ekaitz Zarraga Subject: Re: bug#73188: PEG parser does not support full PEG grammar In-Reply-To: <168e01eb-ac58-4d39-a960-46624e65edde@elenq.tech> (Ekaitz Zarraga's message of "Sun, 13 Oct 2024 22:59:22 +0200") References: <78a81bc5-cd0d-0506-185b-c733c66e96ae@elenq.tech> <20240912205751.23724-1-ekaitz@elenq.tech> <87cyk3rbkc.fsf_-_@gnu.org> <168e01eb-ac58-4d39-a960-46624e65edde@elenq.tech> X-URL: http://www.fdn.fr/~lcourtes/ X-Revolutionary-Date: Tridi 23 =?utf-8?Q?Vend=C3=A9miaire?= an 233 de la =?utf-8?Q?R=C3=A9volution=2C?= jour du Navet X-PGP-Key-ID: 0x090B11993D9AEBB5 X-PGP-Key: http://www.fdn.fr/~lcourtes/ludovic.asc X-PGP-Fingerprint: 3CE4 6455 8A84 FDC6 9DB4 0CFB 090B 1199 3D9A EBB5 X-OS: x86_64-pc-linux-gnu Date: Mon, 14 Oct 2024 13:56:04 +0200 Message-ID: <875xpu3nl7.fsf@gnu.org> User-Agent: Gnus/5.13 (Gnus v5.13) MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 73188 Cc: 73188@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) Saluton! Ekaitz Zarraga skribis: > On 2024-10-13 22:29, Ludovic Court=C3=A8s wrote: >> Hi Ekaitz, >> Ekaitz Zarraga skribis: [...] >>> It adds support for the missing features (comments, underscores in >>> identifiers and escaping) while keeping the extensions (dashes in >>> identifiers, < and <--). >>> >>> The naming system tries to be as close as possible to the one proposed >>> in the paper. >>> >>> * module/ice-9/peg/string-peg.scm: Rewrite PEG parser. >>> * test-suite/tests/peg.test: Fix import [...] >> 1. Is the name change for lexical elements (camel case instead of >> lower-case + hyphens) user-visible? I guess no but better be safe >> than sorry. > > I think they can be, in a very weird way. If using `peg-as-peg` or > something they can be used, but the ones coming from the PEG in text, > which makes way more sense written like in the paper. I'm not sure if > there's another way to make them available, but I don't think there > is. > > I exported `Grammar` as `peg-grammar` because of this. So the users > should just use `peg-grammar` for their things. Sounds good. As long as we don=E2=80=99t unwillingly introduce API incompatibilities, that is fine. >> 2. Could you add tests for the missing features that this adds, and >> maybe extend =E2=80=98api-peg.texi=E2=80=99 accordingly too? > > It doesn't really add much new in this first case, but it makes it > work as expected in PEG, which is what documentation already claimed > to do, and the code didn't actually implement. Mostly what this commit > adds is escaping support in the PEG string literals. I was referring to the features mentioned in the commit log, namely comments, underscores in identifiers, and escaping. >> 3. You can choose to assign copyright to the FSF or to not do that=C2= =B9. >> In the latter case, please add a copyright line for you where >> appropriate. > > I don't care (maybe I should?). I just want this to work properly. So, copyright line I guess. :-) Thanks, Ludo=E2=80=99. From debbugs-submit-bounces@debbugs.gnu.org Mon Oct 14 14:47:16 2024 Received: (at 73188) by debbugs.gnu.org; 14 Oct 2024 18:47:16 +0000 Received: from localhost ([127.0.0.1]:44353 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1t0Q66-00084c-Ds for submit@debbugs.gnu.org; Mon, 14 Oct 2024 14:47:16 -0400 Received: from dane.soverin.net ([185.233.34.30]:48761) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1t0Q62-000843-BS for 73188@debbugs.gnu.org; Mon, 14 Oct 2024 14:47:13 -0400 Received: from smtp.soverin.net (unknown [10.10.4.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by dane.soverin.net (Postfix) with ESMTPS id 4XRzPw4FPFz2xkF; Mon, 14 Oct 2024 14:00:04 +0000 (UTC) Received: from smtp.soverin.net (smtp.soverin.net [10.10.4.99]) by soverin.net (Postfix) with ESMTPSA id 4XRzPv6bfpz3V; Mon, 14 Oct 2024 14:00:03 +0000 (UTC) Authentication-Results: smtp.soverin.net; dkim=pass (2048-bit key; unprotected) header.d=elenq.tech header.i=@elenq.tech header.a=rsa-sha256 header.s=soverin1 header.b=YVMXsuiL; dkim-atps=neutral DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=elenq.tech; s=soverin1; t=1728914404; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: in-reply-to:in-reply-to:references:references:autocrypt:autocrypt; bh=kd31iNZI3bBz39wo4CN+ofN8A4B+CopF+NQ/rk1YjxI=; b=YVMXsuiLlDYw6cLBzxg7gbPVLKVPDEJEqAt5Uxi5ohVTJStO1EdhVnzdmBb4krnJHhi2j+ jO3pEZWknj2KX07IIhrq4YDfOqaM5q7OXxzXRyiHRpKe36qGD+gKZ4JGE2WaGu7yEIMAVk UH5UhIOZDklSKrOXIZWRKhZ1wR1gsQFm0vKCrfV31vn5QGfDf2eoLoDlzW8XNeNOVcRH3s a5ZbrLkwjdbrql/ESkJqXjyY9Gq00kwXJbMAv/TlS4G3zmrxM0FO3Mz4fbHYqOntd5BcAN 6UQtfpSmknE8UJ/Q+WMJAevdQW3rXYQxl7XJ3vtgdrRimgm++zQRNvWc0i0HPg== Content-Type: multipart/mixed; boundary="------------3N0zblOVoqBRwSKdoRkb0HaK" Message-ID: Date: Mon, 14 Oct 2024 16:00:02 +0200 MIME-Version: 1.0 Subject: Re: bug#73188: PEG parser does not support full PEG grammar To: =?UTF-8?Q?Ludovic_Court=C3=A8s?= References: <78a81bc5-cd0d-0506-185b-c733c66e96ae@elenq.tech> <20240912205751.23724-1-ekaitz@elenq.tech> <87cyk3rbkc.fsf_-_@gnu.org> <168e01eb-ac58-4d39-a960-46624e65edde@elenq.tech> <875xpu3nl7.fsf@gnu.org> Content-Language: en-US, es-ES, eu From: Ekaitz Zarraga Autocrypt: addr=ekaitz@elenq.tech; keydata= xsFNBGViSyIBEADY3g71uW/0CVaVm5/ObqTicQXXJRuh1uafIFiUUZoAp1V3V89b3LZ/m0cL 8YNHxTxsx8sKIMYTGlOvARAMiSpDvkmpf5pLn5T7+VvK90FOv/Pkp1tNNT+tvd0m/7C58+39 s7tN+XppbjVRtFuSXY0aFe8rpivZsKxv+tPUHUnQQszXvwgx0GQl8AX99IE+j75NJmBHFVg2 0geKa7QVymu669ix2+zU8vGoOKf5nIS0qG1m/vrtwR3ZuuyWX9/E/uP95ahX5ETWtjhTDbEm MEaRperwbczBewkdERJ34vRrverqKQA1xHXoPsx4NkLMocORFSSCJsveXcgWlU+pUIOYcKUA ARJjHhoWoUH4LZt5EOb7U17AaYMmATUXPCqq8G3jEXq6i0O1J1obCJGIRG02R9GiGp4zrVuv 2hmyoAmed4xYZAtf9WjcbwiunDkMGIxscdSlfEH/9dt7PGdEvkZ0dNSCTbp4ctMI4jAfobAL LReMSGx1CgPi01J61a/n/SgR66AiRJZCyC1u2V7AK1rBOAYzOU4UoePz+yF1I7crjZWAQVo6 DlmmXW+29l/lh2oK5jOuNEcvI6qi+tPCYxpDhUhZeYgqFU+/xgGlMj/XGvwuIFlpVg9ovFMg 6mxskOCVP9xNEp/qHiHqByYu5NRcITo/z/3BUimdXTT4KSq2cQARAQABzSJFa2FpdHogWmFy cmFnYSA8ZWthaXR6QGVsZW5xLnRlY2g+wsGOBBMBCAA4FiEEg/pnRVjAUpRlfkwZt5lM+Jly CyYFAmViSyICGwMFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQt5lM+JlyCybjZxAAy+YW 3Q22xKoMWJYw03qGCy87WPK+xGWDpKD6TJ77+/IEbldObyQRrKYTTGjQSy6WgaJ0txJMIqeK JyuWuR3bq+Vkh86Byntl25jknOJ+jY1zwPs6HnWFr+hS48FcQh/0D26h57Cqc+6nbKhJcva8 JsInbHTbWPz7wye+xhqY1LfdgVTbCyADESXdmBY30/vP4LzqW81atwYF6X7dN7ko/JvyPPdv VlcspmbP6zNihoApBHdMfJwYscyAsu6tTyL4hMG3zpraeU+S857vZN39gFagRng+uyZG7rfB dHHAFzT1LKOZ4dahavOfA0gS1RZTgtAGsvhUEBn9vKxlB4efZuKhwMtgQEskRFD6JIF1DYCj pLgn5x/y3oI6rn35R46VDhLfohcUWpvzplu6LBft8ZNr+UgoVYc6qBezyDlxk0FmhGI7DEoh gfUxljTALXjSdUGEw2mvp/Mcrz+ffemWpG4+Zq0UXR8sZaHpv+PqmFLFFSQCOCRTYbMKzZBn y03wym3y0tGtunDGm5pR7NEPqUO9QbZdKyTy4ftRkSfTpiPCF8+KKYDT8HimSrusmtTfR4R1 nBJ4lNBYgTdOyJYFbHdF0Jxo9r0t+K2e+6hX6bK79o6aC+/LtzkoYgjCWvAEopO0ras/XQYM S7/bCzeDIhXX5RqmMIp5XN+oBP2roZDOwU0EZWJLIgEQAMIgPDpJY9aOhFiFICx58XMM28An yUPdN39t0A8VkUbsvKXH6eNqUZj/Q3yNcZrknAT1vinv9FN/4uCUnsaqEKp+mRAYgzmNfeJk SWuMzmA04fcISIBz3sJUR0w/59tWi8QxlNn7IR6McAA3lHDXC+KYh9ZfhaOARfan1M6Ppy6g YltUQGSSPXU807inmQZh8GFTi8iUza7vGuBEnaNRGhmhR+blMwHSqVWN4gD81e8dSAEi3zNR sLoBXneHUqTcJMHvsT5cOk7cGMoVAWIffA2EKWfrgda57Qw+w+0OPqWEfKoXwnyt35Tl+Lxl 7MAaAG9R5760yhgkf3LmnBNP3m6StZ8Fv09Gdn5cGSbVnoofHDkg4PQDTD6aGz9af3SnGVg9 nb1Zm1XbqtnYwG9JvQhcjgWAHwrPLkHAcvKtfYWNe4wiirMjXMXxADY08g33SEchPJR2r4pg wttJS4kHUJ2IQUmSH/43RO5PkftWsCucYGeaG1aPr+GAkeKIS1M3OZGuqhd800mltpiH73eL XrUPF8fgngC+SGMrHXLfzuhaRxPNYUbsdF+wRkvjRSO4tCmSVpgfPsHu5emoZgix1iiTO7GF do7L6n1Ay3oF4Witoxc0Gcbu7ltYlZHGmDnsVTVALartsJV2muSXpWcjQiXyC0gUkIkUD/3P jtgVxK8xABEBAAHCwXYEGAEIACAWIQSD+mdFWMBSlGV+TBm3mUz4mXILJgUCZWJLIgIbDAAK CRC3mUz4mXILJrIaD/9CXGckwRCojuRzP0r6+8/RvNDc03CSe2W17WrSaoYgiRb+h5asI/AL yqw+QRgwXZpt0i9hNiDCe/baD62mufIyjKFjHoAWSYJuZ5VK3vWnro6GaxWULYt1+c4c4Lz2 d1nSK6j8F3CxYo7BFk6afOusjYfh+0HywThcYY+x+K5Z+4SdJejDLiL5AzJn2W5Gt/ViK5nI wl7uRQpayMc9zmI8ytUT2NJxovq1/fT9nB8VPwlbJTE9zvIqfqHh9o9Apx5o8yTaSCyGUyu9 8h/klqxFy4HAPJJu/3JkiMaCI45ZdCqRR1LIwhtmW2lb73r0rP/0S1cKi+ehA4oQvwiUw7zh XXw7mqzSAJ0SWT92Vy2G8Z8qqgwxwfQcdFZAyJAL1rgEPQljNT91Vgbc6DCUka2XW5BqyhEB eS0n1gK0hYXbM9FKegRsZxlmRAXa4KGXCwr4BNK6k+zkKPitezjbtcLgcKSHa8/HyHNkW7xH R+MN16x2elQPmQ2d0Ien1HgsK98+3prlUGwZIVCqa1ddSoW0llU3JzGsKrMAiYbWg/rOXFil RJbuhjflaLBVmfI8VlRQRocP+WEH0lsUWrtjVaGcBj1/YnIoT+zT6fPSXwPsrBvAWEjfl8HH e1F4cYb+ugPDwUTd1s2Uj2tF0/fhCHPy9sXyx/EIL3gqyBw9M2Rz9A== In-Reply-To: <875xpu3nl7.fsf@gnu.org> X-Spampanel-Class: ham X-Spam-Score: -0.7 (/) X-Debbugs-Envelope-To: 73188 Cc: 73188@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.7 (-) This is a multi-part message in MIME format. --------------3N0zblOVoqBRwSKdoRkb0HaK Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 7bit Hi, So I reviewed the suggestions and this what I have: - Added the comment - Added my copyright line - Nothing in Guix is affected by the changes proposed here, because there's no use of `string-peg` and I didn't change how the S-Expression based PEG works. - The changes applied here only affect to the PEG written as PEG strings and their processing, which was introduced in the documentation as "read the wikipedia", but our PEG definition wasn't implementing the real PEG explained in that wikipedia link. Our documentation claimed that we were able to do things we were not able to do. - I added a link to the paper we are following below the link to the wikipedia page just in case, to let our users know exactly what does our PEG support. The paper says: Literals and character classes can contain C-like escape codes That should be enough for anyone. Also we support `-` in identifiers, but our documentation already said that. I replaced the description of what normal PEG supports. Our docs said PEG only supported alphabetic characters but it has never been true, the paper explains PEG supports alpha, numeric and `_`, but the numeric cannot be the first character (like C identifiers). - What it is true is if people were using `peg-as-peg` for their things, which isn't even exported by the module, their code would have problems. But we can't predict that. - In summary, what I implemented here is a PEG string to PEG Sexp compiler. So it shouldn't affect anyone that uses the PEG Sexp directly and if I did my work properly it shouldn't affect those that used their PEG patterns in strings either, because I only made it work closely to what the paper said, adding a couple of missing features. EXTRA: I rebased the support for the `not-in-range` part, that does touch the PEG sexp part, but only adds more functionality without affecting anything that already existed. In following days I'll review Error reporting and captures that were added in a different thread in guile-devel and see if we can integrate everything to create a production ready PEG parser. Thanks! Ekaitz I attached both patches. --------------3N0zblOVoqBRwSKdoRkb0HaK Content-Type: text/x-patch; charset=UTF-8; name="v3-0001-PEG-Add-full-support-for-PEG-some-extensions.patch" Content-Disposition: attachment; filename*0="v3-0001-PEG-Add-full-support-for-PEG-some-extensions.patch" Content-Transfer-Encoding: base64 RnJvbSA4MTk0NGMyMDM3ZTBkNmQ4Yzk3MmRlZjJjZWIxYWE0YzUxYTYxNDMxIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBFa2FpdHogWmFycmFnYSA8ZWthaXR6QGVsZW5xLnRl Y2g+CkRhdGU6IFdlZCwgMTEgU2VwIDIwMjQgMjE6MTk6MjYgKzAyMDAKU3ViamVjdDogW1BB VENIIHYzIDEvMl0gUEVHOiBBZGQgZnVsbCBzdXBwb3J0IGZvciBQRUcgKyBzb21lIGV4dGVu c2lvbnMKClRoaXMgY29tbWl0IGFkZHMgc3VwcG9ydCBmb3IgUEVHIGFzIGRlc2NyaWJlZCBp bjoKCiAgICA8aHR0cHM6Ly9iZm9yZC5pbmZvL3B1Yi9sYW5nL3BlZy5wZGY+CgpJdCBhZGRz IHN1cHBvcnQgZm9yIHRoZSBtaXNzaW5nIGZlYXR1cmVzIChjb21tZW50cywgdW5kZXJzY29y ZXMgaW4KaWRlbnRpZmllcnMgYW5kIGVzY2FwaW5nKSB3aGlsZSBrZWVwaW5nIHRoZSBleHRl bnNpb25zIChkYXNoZXMgaW4KaWRlbnRpZmllcnMsIDwgYW5kIDwtLSkuCgpUaGUgbmFtaW5n IHN5c3RlbSB0cmllcyB0byBiZSBhcyBjbG9zZSBhcyBwb3NzaWJsZSB0byB0aGUgb25lIHBy b3Bvc2VkCmluIHRoZSBwYXBlci4KCiogbW9kdWxlL2ljZS05L3BlZy9zdHJpbmctcGVnLnNj bTogUmV3cml0ZSBQRUcgcGFyc2VyLgoqIHRlc3Qtc3VpdGUvdGVzdHMvcGVnLnRlc3Q6IEZp eCBpbXBvcnQKLS0tCiBkb2MvcmVmL2FwaS1wZWcudGV4aSAgICAgICAgICAgIHwgICA4ICst CiBtb2R1bGUvaWNlLTkvcGVnL3N0cmluZy1wZWcuc2NtIHwgNDQyICsrKysrKysrKysrKysr KysrKysrLS0tLS0tLS0tLS0tCiB0ZXN0LXN1aXRlL3Rlc3RzL3BlZy50ZXN0ICAgICAgIHwg IDMyICsrLQogMyBmaWxlcyBjaGFuZ2VkLCAzMDIgaW5zZXJ0aW9ucygrKSwgMTgwIGRlbGV0 aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RvYy9yZWYvYXBpLXBlZy50ZXhpIGIvZG9jL3JlZi9h cGktcGVnLnRleGkKaW5kZXggZDM0ZGRjNjRjLi44NGE5ZTZjNmIgMTAwNjQ0Ci0tLSBhL2Rv Yy9yZWYvYXBpLXBlZy50ZXhpCisrKyBiL2RvYy9yZWYvYXBpLXBlZy50ZXhpCkBAIC0xNyw2 ICsxNywxMCBAQCBXaWtpcGVkaWEgaGFzIGEgY2xlYXIgYW5kIGNvbmNpc2UgaW50cm9kdWN0 aW9uIHRvIFBFR3MgaWYgeW91IHdhbnQgdG8KIGZhbWlsaWFyaXplIHlvdXJzZWxmIHdpdGgg dGhlIHN5bnRheDoKIEB1cmx7aHR0cDovL2VuLndpa2lwZWRpYS5vcmcvd2lraS9QYXJzaW5n X2V4cHJlc3Npb25fZ3JhbW1hcn0uCiAKK1RoZSBwYXBlciB0aGF0IGludHJvZHVjZWQgUEVH IGNvbnRhaW5zIGEgbW9yZSBkZXRhaWxlZCBkZXNjcmlwdGlvbiBvZiBob3cgUEVHCit3b3Jr cywgYW5kIGRlc2NyaWJlcyBpdHMgc3ludGF4IGluIGRldGFpbDoKK0B1cmx7aHR0cHM6Ly9i Zm9yZC5pbmZvL3B1Yi9sYW5nL3BlZy5wZGZ9CisKIFRoZSBAY29kZXsoaWNlLTkgcGVnKX0g bW9kdWxlIHdvcmtzIGJ5IGNvbXBpbGluZyBQRUdzIGRvd24gdG8gbGFtYmRhCiBleHByZXNz aW9ucy4gIFRoZXNlIGNhbiBlaXRoZXIgYmUgc3RvcmVkIGluIHZhcmlhYmxlcyBhdCBjb21w aWxlLXRpbWUgYnkKIHRoZSBkZWZpbmUgbWFjcm9zIChAY29kZXtkZWZpbmUtcGVnLXBhdHRl cm59IGFuZApAQCAtMjE2LDggKzIyMCw4IEBAIHNob3VsZCBwcm9wYWdhdGUgdXAgdGhlIHBh cnNlIHRyZWUuICBUaGUgbm9ybWFsIEBjb2RlezwtfSBwcm9wYWdhdGVzIHRoZQogbWF0Y2hl ZCB0ZXh0IHVwIHRoZSBwYXJzZSB0cmVlLCBAY29kZXs8LS19IHByb3BhZ2F0ZXMgdGhlIG1h dGNoZWQgdGV4dAogdXAgdGhlIHBhcnNlIHRyZWUgdGFnZ2VkIHdpdGggdGhlIG5hbWUgb2Yg dGhlIG5vbnRlcm1pbmFsLCBhbmQgQGNvZGV7PH0KIGRpc2NhcmRzIHRoYXQgbWF0Y2hlZCB0 ZXh0IGFuZCBwcm9wYWdhdGVzIG5vdGhpbmcgdXAgdGhlIHBhcnNlIHRyZWUuCi1BbHNvLCBu b250ZXJtaW5hbHMgbWF5IGNvbnNpc3Qgb2YgYW55IGFscGhhbnVtZXJpYyBjaGFyYWN0ZXIg b3IgYSBgYC0nJwotY2hhcmFjdGVyIChpbiBub3JtYWwgUEVHcyBub250ZXJtaW5hbHMgY2Fu IG9ubHkgYmUgYWxwaGFiZXRpYykuCitBbHNvLCBub250ZXJtaW5hbHMgbWF5IGluY2x1ZGUg YGAtJycgY2hhcmFjdGVyLCB3aGlsZSBpbiBub3JtYWwgUEVHIGl0IGlzIG5vdAorYWxsb3dl ZC4KIAogRm9yIGV4YW1wbGUsIGlmIHdlOgogQGxpc3AKZGlmZiAtLWdpdCBhL21vZHVsZS9p Y2UtOS9wZWcvc3RyaW5nLXBlZy5zY20gYi9tb2R1bGUvaWNlLTkvcGVnL3N0cmluZy1wZWcu c2NtCmluZGV4IDQ1ZWQxNGJiMS4uZjY4ODY1M2VmIDEwMDY0NAotLS0gYS9tb2R1bGUvaWNl LTkvcGVnL3N0cmluZy1wZWcuc2NtCisrKyBiL21vZHVsZS9pY2UtOS9wZWcvc3RyaW5nLXBl Zy5zY20KQEAgLTEsNiArMSw3IEBACiA7Ozs7IHN0cmluZy1wZWcuc2NtIC0tLSByZXByZXNl bnRpbmcgUEVHIGdyYW1tYXJzIGFzIHN0cmluZ3MKIDs7OzsKLTs7OzsgCUNvcHlyaWdodCAo QykgMjAxMCwgMjAxMSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4KKzs7OzsgCUNv cHlyaWdodCAoQykgMjAxMCwgMjAxMSwgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMu Cis7Ozs7IAlDb3B5cmlnaHQgKEMpIDIwMjQgRWthaXR6IFphcnJhZ2EgPGVrYWl0ekBlbGVu cS50ZWNoPgogOzs7OwogOzs7OyBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91 IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiA7Ozs7IG1vZGlmeSBpdCB1bmRlciB0aGUg dGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKQEAgLTIyLDkgKzIzLDEz IEBACiAgICAgICAgICAgICBkZWZpbmUtcGVnLXN0cmluZy1wYXR0ZXJucwogICAgICAgICAg ICAgcGVnLWdyYW1tYXIpCiAgICM6dXNlLW1vZHVsZSAoaWNlLTkgcGVnIHVzaW5nLXBhcnNl cnMpCisgICM6dXNlLW1vZHVsZSAoc3JmaSBzcmZpLTEpCiAgICM6dXNlLW1vZHVsZSAoaWNl LTkgcGVnIGNvZGVnZW4pCiAgICM6dXNlLW1vZHVsZSAoaWNlLTkgcGVnIHNpbXBsaWZ5LXRy ZWUpKQogCis7OyBUaGlzIG1vZHVsZSBwcm92aWRlcyBzdXBwb3J0IGZvciBQRUcgYXMgZGVz Y3JpYmVkIGluOgorOzsgICA8aHR0cHM6Ly9iZm9yZC5pbmZvL3B1Yi9sYW5nL3BlZy5wZGY+ CisKIDs7IEdldHMgdGhlIGxlZnQtaGFuZCBkZXB0aCBvZiBhIGxpc3QuCiAoZGVmaW5lIChk ZXB0aCBsc3QpCiAgIChpZiAob3IgKG5vdCAobGlzdD8gbHN0KSkgKG51bGw/IGxzdCkpCkBA IC0zOCwyMiArNDMsNTcgQEAKIAogOzsgR3JhbW1hciBmb3IgUEVHcyBpbiBQRUcgZ3JhbW1h ci4KIChkZWZpbmUgcGVnLWFzLXBlZwotImdyYW1tYXIgPC0tIChub250ZXJtaW5hbCAoJzwt LScgLyAnPC0nIC8gJzwnKSBzcCBwYXR0ZXJuKSsKLXBhdHRlcm4gPC0tIGFsdGVybmF0aXZl IChTTEFTSCBzcCBhbHRlcm5hdGl2ZSkqCi1hbHRlcm5hdGl2ZSA8LS0gKFshJl0/IHNwIHN1 ZmZpeCkrCi1zdWZmaXggPC0tIHByaW1hcnkgKFsqKz9dIHNwKSoKLXByaW1hcnkgPC0tICco JyBzcCBwYXR0ZXJuICcpJyBzcCAvICcuJyBzcCAvIGxpdGVyYWwgLyBjaGFyY2xhc3MgLyBu b250ZXJtaW5hbCAhJzwnCi1saXRlcmFsIDwtLSBbJ10gKCFbJ10gLikqIFsnXSBzcAotY2hh cmNsYXNzIDwtLSBMQiAoISddJyAoQ0NyYW5nZSAvIENDc2luZ2xlKSkqIFJCIHNwCi1DQ3Jh bmdlIDwtLSAuICctJyAuCi1DQ3NpbmdsZSA8LS0gLgotbm9udGVybWluYWwgPC0tIFthLXpB LVowLTktXSsgc3AKLXNwIDwgWyBcdFxuXSoKLVNMQVNIIDwgJy8nCi1MQiA8ICdbJwotUkIg PCAnXScKKyIjIEhpZXJhcmNoaWNhbCBzeW50YXgKK0dyYW1tYXIgPC0tIFNwYWNpbmcgRGVm aW5pdGlvbisgRW5kT2ZGaWxlCitEZWZpbml0aW9uIDwtLSBJZGVudGlmaWVyIExFRlRBUlJP VyBFeHByZXNzaW9uCisKK0V4cHJlc3Npb24gPC0tIFNlcXVlbmNlIChTTEFTSCBTZXF1ZW5j ZSkqCitTZXF1ZW5jZSA8LS0gUHJlZml4KgorUHJlZml4IDwtLSAoQU5EIC8gTk9UKT8gU3Vm Zml4CitTdWZmaXggPC0tIFByaW1hcnkgKFFVRVNUSU9OIC8gU1RBUiAvIFBMVVMpPworUHJp bWFyeSA8LS0gSWRlbnRpZmllciAhTEVGVEFSUk9XCisgICAgICAgICAgIC8gT1BFTiBFeHBy ZXNzaW9uIENMT1NFCisgICAgICAgICAgIC8gTGl0ZXJhbCAvIENsYXNzIC8gRE9UCisKKyMg TGV4aWNhbCBzeW50YXgKK0lkZW50aWZpZXIgPC0tIElkZW50U3RhcnQgSWRlbnRDb250KiBT cGFjaW5nCisjIE5PVEU6IGAtYCBpcyBhbiBleHRlbnNpb24KK0lkZW50U3RhcnQgPC0gW2Et ekEtWl9dIC8gJy0nCitJZGVudENvbnQgPC0gSWRlbnRTdGFydCAvIFswLTldCisKK0xpdGVy YWwgPC0tIFNRVU9URSAoIVNRVU9URSBDaGFyKSogU1FVT1RFIFNwYWNpbmcKKyAgICAgICAg LyBEUVVPVEUgKCFEUVVPVEUgQ2hhcikqIERRVU9URSBTcGFjaW5nCitDbGFzcyA8LS0gJ1sn ICghJ10nIFJhbmdlKSogJ10nIFNwYWNpbmcKK1JhbmdlIDwtLSBDaGFyICctJyBDaGFyIC8g Q2hhcgorQ2hhciA8LS0gJ1xcXFwnIFtucnQnXCJcXFtcXF1cXFxcXQorICAgICAgIC8gJ1xc XFwnIFswLTddWzAtN11bMC03XQorICAgICAgIC8gJ1xcXFwnIFswLTddWzAtN10/CisgICAg ICAgLyAhJ1xcXFwnIC4KKworIyBOT1RFOiBgPC0tYCBhbmQgYDxgIGFyZSBleHRlbnNpb25z CitMRUZUQVJST1cgPC0gKCc8LS0nIC8gJzwtJyAvICc8JykgU3BhY2luZworU1FVT1RFIDwt LSBbJ10KK0RRVU9URSA8LS0gW1wiXQorT1BFTkJSQUNLRVQgPCAnWycKK0NMT1NFQlJBQ0tF VCA8ICddJworU0xBU0ggPCAnLycgU3BhY2luZworQU5EIDwtLSAnJicgU3BhY2luZworTk9U IDwtLSAnIScgU3BhY2luZworUVVFU1RJT04gPC0tICc/JyBTcGFjaW5nCitTVEFSIDwtLSAn KicgU3BhY2luZworUExVUyA8LS0gJysnIFNwYWNpbmcKK09QRU4gPCAnKCcgU3BhY2luZwor Q0xPU0UgPCAnKScgU3BhY2luZworRE9UIDwtLSAnLicgU3BhY2luZworCitTcGFjaW5nIDwg KFNwYWNlIC8gQ29tbWVudCkqCitDb21tZW50IDwgJyMnICghRW5kT2ZMaW5lIC4pKiBFbmRP ZkxpbmUKK1NwYWNlIDwgJyAnIC8gJ1x0JyAvIEVuZE9mTGluZQorRW5kT2ZMaW5lIDwgJ1xc clxcbicgLyAnXFxuJyAvICdcXHInCitFbmRPZkZpbGUgPCAhLgogIikKIAorCiAoZGVmaW5l LXN5bnRheCBkZWZpbmUtc2V4cC1wYXJzZXIKICAgKGxhbWJkYSAoeCkKICAgICAoc3ludGF4 LWNhc2UgeCAoKQpAQCAtNjMsMzUgKzEwMyw3OCBAQCBSQiA8ICddJwogICAgICAgICAgICAg ICAoc3luICh3cmFwLXBhcnNlci1mb3ItdXNlcnMgeCBtYXRjaGYgYWNjdW1zeW0gIydzeW0p KSkKICAgICAgICAgICAgI2AoZGVmaW5lIHN5bSAjLHN5bikpKSkpKQogCi0oZGVmaW5lLXNl eHAtcGFyc2VyIHBlZy1ncmFtbWFyIGFsbAotICAoKyAoYW5kIHBlZy1ub250ZXJtaW5hbCAo b3IgIjwtLSIgIjwtIiAiPCIpIHBlZy1zcCBwZWctcGF0dGVybikpKQotKGRlZmluZS1zZXhw LXBhcnNlciBwZWctcGF0dGVybiBhbGwKLSAgKGFuZCBwZWctYWx0ZXJuYXRpdmUKLSAgICAg ICAoKiAoYW5kIChpZ25vcmUgIi8iKSBwZWctc3AgcGVnLWFsdGVybmF0aXZlKSkpKQotKGRl ZmluZS1zZXhwLXBhcnNlciBwZWctYWx0ZXJuYXRpdmUgYWxsCi0gICgrIChhbmQgKD8gKG9y ICIhIiAiJiIpKSBwZWctc3AgcGVnLXN1ZmZpeCkpKQotKGRlZmluZS1zZXhwLXBhcnNlciBw ZWctc3VmZml4IGFsbAotICAoYW5kIHBlZy1wcmltYXJ5ICgqIChhbmQgKG9yICIqIiAiKyIg Ij8iKSBwZWctc3ApKSkpCi0oZGVmaW5lLXNleHAtcGFyc2VyIHBlZy1wcmltYXJ5IGFsbAot ICAob3IgKGFuZCAiKCIgcGVnLXNwIHBlZy1wYXR0ZXJuICIpIiBwZWctc3ApCi0gICAgICAo YW5kICIuIiBwZWctc3ApCi0gICAgICBwZWctbGl0ZXJhbAotICAgICAgcGVnLWNoYXJjbGFz cwotICAgICAgKGFuZCBwZWctbm9udGVybWluYWwgKG5vdC1mb2xsb3dlZC1ieSAiPCIpKSkp Ci0oZGVmaW5lLXNleHAtcGFyc2VyIHBlZy1saXRlcmFsIGFsbAotICAoYW5kICInIiAoKiAo YW5kIChub3QtZm9sbG93ZWQtYnkgIiciKSBwZWctYW55KSkgIiciIHBlZy1zcCkpCi0oZGVm aW5lLXNleHAtcGFyc2VyIHBlZy1jaGFyY2xhc3MgYWxsCi0gIChhbmQgKGlnbm9yZSAiWyIp Ci0gICAgICAgKCogKGFuZCAobm90LWZvbGxvd2VkLWJ5ICJdIikKLSAgICAgICAgICAgICAg IChvciBjaGFyY2xhc3MtcmFuZ2UgY2hhcmNsYXNzLXNpbmdsZSkpKQotICAgICAgIChpZ25v cmUgIl0iKQotICAgICAgIHBlZy1zcCkpCi0oZGVmaW5lLXNleHAtcGFyc2VyIGNoYXJjbGFz cy1yYW5nZSBhbGwgKGFuZCBwZWctYW55ICItIiBwZWctYW55KSkKLShkZWZpbmUtc2V4cC1w YXJzZXIgY2hhcmNsYXNzLXNpbmdsZSBhbGwgcGVnLWFueSkKLShkZWZpbmUtc2V4cC1wYXJz ZXIgcGVnLW5vbnRlcm1pbmFsIGFsbAotICAoYW5kICgrIChvciAocmFuZ2UgI1xhICNceikg KHJhbmdlICNcQSAjXFopIChyYW5nZSAjXDAgI1w5KSAiLSIpKSBwZWctc3ApKQotKGRlZmlu ZS1zZXhwLXBhcnNlciBwZWctc3Agbm9uZQotICAoKiAob3IgIiAiICJcdCIgIlxuIikpKQor KGRlZmluZS1zZXhwLXBhcnNlciBHcmFtbWFyIGFsbAorICAoYW5kIFNwYWNpbmcgKCsgRGVm aW5pdGlvbikgRW5kT2ZGaWxlKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgRGVmaW5pdGlvbiBh bGwKKyAgKGFuZCBJZGVudGlmaWVyIExFRlRBUlJPVyBFeHByZXNzaW9uKSkKKyhkZWZpbmUt c2V4cC1wYXJzZXIgRXhwcmVzc2lvbiBhbGwKKyAgKGFuZCBTZXF1ZW5jZSAoKiAoYW5kIFNM QVNIIFNlcXVlbmNlKSkpKQorKGRlZmluZS1zZXhwLXBhcnNlciBTZXF1ZW5jZSBhbGwKKyAg KCogUHJlZml4KSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgUHJlZml4IGFsbAorICAoYW5kICg/ IChvciBBTkQgTk9UKSkgU3VmZml4KSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgU3VmZml4IGFs bAorICAoYW5kIFByaW1hcnkgKD8gKG9yIFFVRVNUSU9OIFNUQVIgUExVUykpKSkKKyhkZWZp bmUtc2V4cC1wYXJzZXIgUHJpbWFyeSBhbGwKKyAgKG9yIChhbmQgSWRlbnRpZmllciAobm90 LWZvbGxvd2VkLWJ5IExFRlRBUlJPVykpCisgICAgICAoYW5kIE9QRU4gRXhwcmVzc2lvbiBD TE9TRSkKKyAgICAgIExpdGVyYWwKKyAgICAgIENsYXNzCisgICAgICBET1QpKQorKGRlZmlu ZS1zZXhwLXBhcnNlciBJZGVudGlmaWVyIGFsbAorICAoYW5kIElkZW50U3RhcnQgKCogSWRl bnRDb250KSBTcGFjaW5nKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgSWRlbnRTdGFydCBib2R5 CisgIChvciAocmFuZ2UgI1xhICNceikgKHJhbmdlICNcQSAjXFopICJfIiAiLSIpKSA7IE5P VEU6IC0gaXMgYW4gZXh0ZW5zaW9uCisoZGVmaW5lLXNleHAtcGFyc2VyIElkZW50Q29udCBi b2R5CisgIChvciBJZGVudFN0YXJ0IChyYW5nZSAjXDAgI1w5KSkpCisoZGVmaW5lLXNleHAt cGFyc2VyIExpdGVyYWwgYWxsCisgIChvciAoYW5kIFNRVU9URSAoKiAoYW5kIChub3QtZm9s bG93ZWQtYnkgU1FVT1RFKSBDaGFyKSkgU1FVT1RFIFNwYWNpbmcpCisgICAgICAoYW5kIERR VU9URSAoKiAoYW5kIChub3QtZm9sbG93ZWQtYnkgRFFVT1RFKSBDaGFyKSkgRFFVT1RFIFNw YWNpbmcpKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgQ2xhc3MgYWxsCisgIChhbmQgT1BFTkJS QUNLRVQgKCogKGFuZCAobm90LWZvbGxvd2VkLWJ5IENMT1NFQlJBQ0tFVCkgUmFuZ2UpKSBD TE9TRUJSQUNLRVQgU3BhY2luZykpCisoZGVmaW5lLXNleHAtcGFyc2VyIFJhbmdlIGFsbAor ICAob3IgKGFuZCBDaGFyIERBU0ggQ2hhcikgQ2hhcikpCisoZGVmaW5lLXNleHAtcGFyc2Vy IENoYXIgYWxsCisgIChvciAoYW5kICJcXCIgKG9yICJuIiAiciIgInQiICInIiAiWyIgIl0i ICJcXCIpKQorICAgICAgKGFuZCAiXFwiIChyYW5nZSAjXDAgI1w3KSAocmFuZ2UgI1wwICNc NykgKHJhbmdlICNcMCAjXDcpKQorICAgICAgKGFuZCAiXFwiIChyYW5nZSAjXDAgI1w3KSAo PyAocmFuZ2UgI1wwICNcNykpKQorICAgICAgKGFuZCAobm90LWZvbGxvd2VkLWJ5ICJcXCIp IHBlZy1hbnkpKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgTEVGVEFSUk9XIGJvZHkKKyAgKGFu ZCAob3IgIjwtLSIgIjwtIiAiPCIpIFNwYWNpbmcpKSA7IE5PVEU6IDwtLSBhbmQgPCBhcmUg ZXh0ZW5zaW9ucworKGRlZmluZS1zZXhwLXBhcnNlciBTTEFTSCBub25lCisgIChhbmQgIi8i IFNwYWNpbmcpKQorKGRlZmluZS1zZXhwLXBhcnNlciBBTkQgYWxsCisgIChhbmQgIiYiIFNw YWNpbmcpKQorKGRlZmluZS1zZXhwLXBhcnNlciBOT1QgYWxsCisgIChhbmQgIiEiIFNwYWNp bmcpKQorKGRlZmluZS1zZXhwLXBhcnNlciBRVUVTVElPTiBhbGwKKyAgKGFuZCAiPyIgU3Bh Y2luZykpCisoZGVmaW5lLXNleHAtcGFyc2VyIFNUQVIgYWxsCisgIChhbmQgIioiIFNwYWNp bmcpKQorKGRlZmluZS1zZXhwLXBhcnNlciBQTFVTIGFsbAorICAoYW5kICIrIiBTcGFjaW5n KSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgT1BFTiBub25lCisgIChhbmQgIigiIFNwYWNpbmcp KQorKGRlZmluZS1zZXhwLXBhcnNlciBDTE9TRSBub25lCisgIChhbmQgIikiIFNwYWNpbmcp KQorKGRlZmluZS1zZXhwLXBhcnNlciBET1QgYWxsCisgIChhbmQgIi4iIFNwYWNpbmcpKQor KGRlZmluZS1zZXhwLXBhcnNlciBTUVVPVEUgbm9uZSAiJyIpCisoZGVmaW5lLXNleHAtcGFy c2VyIERRVU9URSBub25lICJcIiIpCisoZGVmaW5lLXNleHAtcGFyc2VyIE9QRU5CUkFDS0VU IG5vbmUgIlsiKQorKGRlZmluZS1zZXhwLXBhcnNlciBDTE9TRUJSQUNLRVQgbm9uZSAiXSIp CisoZGVmaW5lLXNleHAtcGFyc2VyIERBU0ggbm9uZSAiLSIpCisoZGVmaW5lLXNleHAtcGFy c2VyIFNwYWNpbmcgbm9uZQorICAoKiAob3IgU3BhY2UgQ29tbWVudCkpKQorKGRlZmluZS1z ZXhwLXBhcnNlciBDb21tZW50IG5vbmUKKyAgKGFuZCAiIyIgKCogKGFuZCAobm90LWZvbGxv d2VkLWJ5IEVuZE9mTGluZSkgcGVnLWFueSkpIEVuZE9mTGluZSkpCisoZGVmaW5lLXNleHAt cGFyc2VyIFNwYWNlIG5vbmUKKyAgKG9yICIgIiAiXHQiIEVuZE9mTGluZSkpCisoZGVmaW5l LXNleHAtcGFyc2VyIEVuZE9mTGluZSBub25lCisgIChvciAiXHJcbiIgIlxuIiAiXHIiKSkK KyhkZWZpbmUtc2V4cC1wYXJzZXIgRW5kT2ZGaWxlIG5vbmUKKyAgKG5vdC1mb2xsb3dlZC1i eSBwZWctYW55KSkKKwogCiA7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7 Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OwogOzs7OzsgUEFS U0UgU1RSSU5HIFBFR1MKQEAgLTEwMSw3ICsxODQsNyBAQCBSQiA8ICddJwogOzsgd2lsbCBk ZWZpbmUgYWxsIG9mIHRoZSBub250ZXJtaW5hbHMgaW4gdGhlIGdyYW1tYXIgd2l0aCBlcXVp dmFsZW50CiA7OyBQRUcgcy1leHByZXNzaW9ucy4KIChkZWZpbmUgKHBlZy1wYXJzZXIgc3Ry IGZvci1zeW50YXgpCi0gIChsZXQgKChwYXJzZWQgKG1hdGNoLXBhdHRlcm4gcGVnLWdyYW1t YXIgc3RyKSkpCisgIChsZXQgKChwYXJzZWQgKG1hdGNoLXBhdHRlcm4gR3JhbW1hciBzdHIp KSkKICAgICAoaWYgKG5vdCBwYXJzZWQpCiAgICAgICAgIChiZWdpbgogICAgICAgICAgIDs7 IChkaXNwbGF5ICJJbnZhbGlkIFBFRyBncmFtbWFyIVxuIikKQEAgLTExMCwxMzIgKzE5Mywx NjAgQEAgUkIgPCAnXScKICAgICAgICAgICAoY29uZAogICAgICAgICAgICAoKG9yIChub3Qg KGxpc3Q/IGxzdCkpIChudWxsPyBsc3QpKQogICAgICAgICAgICAgbHN0KQotICAgICAgICAg ICAoKGVxPyAoY2FyIGxzdCkgJ3BlZy1ncmFtbWFyKQotICAgICAgICAgICAgI2AoYmVnaW4K LSAgICAgICAgICAgICAgICAjLEAobWFwIChsYW1iZGEgKHgpIChwZWctbm9udGVybS0+ZGVm biB4IGZvci1zeW50YXgpKQotICAgICAgICAgICAgICAgICAgICAgICAgKGNvbnRleHQtZmxh dHRlbiAobGFtYmRhIChsc3QpICg8PSAoZGVwdGggbHN0KSAyKSkKLSAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgKGNkciBsc3QpKSkpKSkpKSkpCisgICAgICAg ICAgICgoZXE/IChjYXIgbHN0KSAnR3JhbW1hcikKKyAgICAgICAgICAgIChHcmFtbWFyLT5k ZWZuIGxzdCBmb3Itc3ludGF4KSkpKSkpKQogCi07OyBNYWNybyB3cmFwcGVyIGZvciBQRUct UEFSU0VSLiAgUGFyc2VzIFBFRyBncmFtbWFycyBleHByZXNzZWQgYXMgc3RyaW5ncyBhbmQK LTs7IGRlZmluZXMgYWxsIHRoZSBhcHByb3ByaWF0ZSBub250ZXJtaW5hbHMuCi0oZGVmaW5l LXN5bnRheCBkZWZpbmUtcGVnLXN0cmluZy1wYXR0ZXJucwotICAobGFtYmRhICh4KQotICAg IChzeW50YXgtY2FzZSB4ICgpCi0gICAgICAoKF8gc3RyKQotICAgICAgIChwZWctcGFyc2Vy IChzeW50YXgtPmRhdHVtICMnc3RyKSB4KSkpKSkKKzs7IChHcmFtbWFyIChEZWZpbml0aW9u IC4uLikgKERlZmluaXRpb24gLi4uKSkKKyhkZWZpbmUgKEdyYW1tYXItPmRlZm4gbHN0IGZv ci1zeW50YXgpCisgICNgKGJlZ2luCisgICAgICAjLEAobWFwIChsYW1iZGEgKHgpIChEZWZp bml0aW9uLT5kZWZuIHggZm9yLXN5bnRheCkpCisgICAgICAgICAgICAgIChjb250ZXh0LWZs YXR0ZW4gKGxhbWJkYSAobHN0KSAoPD0gKGRlcHRoIGxzdCkgMSkpCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgKGNkciBsc3QpKSkpKQogCi07OyBsc3QgaGFzIGZvcm1hdCAo bm9udGVybSBncmFiYmVyIHBhdHRlcm4pLCB3aGVyZQotOzsgICBub250ZXJtIGlzIGEgc3lt Ym9sICh0aGUgbmFtZSBvZiB0aGUgbm9udGVybWluYWwpLAotOzsgICBncmFiYmVyIGlzIGEg c3RyaW5nIChlaXRoZXIgIjwiLCAiPC0iIG9yICI8LS0iKSwgYW5kCi07OyAgIHBhdHRlcm4g aXMgdGhlIHBhcnNlIG9mIGEgUEVHIHBhdHRlcm4gZXhwcmVzc2VkIGFzIGFzIHN0cmluZy4K LShkZWZpbmUgKHBlZy1ub250ZXJtLT5kZWZuIGxzdCBmb3Itc3ludGF4KQotICAobGV0KiAo KG5vbnRlcm0gKGNhciBsc3QpKQotICAgICAgICAgKGdyYWJiZXIgKGNhZHIgbHN0KSkKLSAg ICAgICAgIChwYXR0ZXJuIChjYWRkciBsc3QpKQotICAgICAgICAgKG5vbnRlcm0tbmFtZSAo ZGF0dW0tPnN5bnRheCBmb3Itc3ludGF4Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIChzdHJpbmctPnN5bWJvbCAoY2FkciBub250ZXJtKSkpKSkKLSAgICAjYChk ZWZpbmUtcGVnLXBhdHRlcm4gIyxub250ZXJtLW5hbWUKKzs7IChEZWZpbml0aW9uIChJZGVu dGlmaWVyICJTb21ldGhpbmciKSAiPC0iIChFeHByZXNzaW9uIC4uLikpCis7OyAgYC0+IChk ZWZpbmUtcGVnLXBhdHRlcm4gU29tZXRoaW5nICdhbGwgLi4uKQorKGRlZmluZSAoRGVmaW5p dGlvbi0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKKyAgKGxldCAoKGlkZW50aWZpZXIgKHNlY29u ZCAoc2Vjb25kIGxzdCkpKQorICAgICAgICAoZ3JhYmJlciAgICAodGhpcmQgIGxzdCkpCisg ICAgICAgIChleHByZXNzaW9uIChmb3VydGggbHN0KSkpCisgICAgI2AoZGVmaW5lLXBlZy1w YXR0ZXJuICMsKGRhdHVtLT5zeW50YXggZm9yLXN5bnRheAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIChzdHJpbmctPnN5bWJvbCBpZGVudGlmaWVyKSkK ICAgICAgICAjLChjb25kCiAgICAgICAgICAgKChzdHJpbmc9PyBncmFiYmVyICI8LS0iKSAo ZGF0dW0tPnN5bnRheCBmb3Itc3ludGF4ICdhbGwpKQogICAgICAgICAgICgoc3RyaW5nPT8g Z3JhYmJlciAiPC0iKSAoZGF0dW0tPnN5bnRheCBmb3Itc3ludGF4ICdib2R5KSkKICAgICAg ICAgICAoZWxzZSAoZGF0dW0tPnN5bnRheCBmb3Itc3ludGF4ICdub25lKSkpCi0gICAgICAg IywoY29tcHJlc3NvciAocGVnLXBhdHRlcm4tPmRlZm4gcGF0dGVybiBmb3Itc3ludGF4KSBm b3Itc3ludGF4KSkpKQotCi07OyBsc3QgaGFzIGZvcm1hdCAoJ3BlZy1wYXR0ZXJuIC4uLiku Ci07OyBBZnRlciB0aGUgY29udGV4dC1mbGF0dGVuLCAoY2RyIGxzdCkgaGFzIGZvcm1hdAot OzsgICAoKCdwZWctYWx0ZXJuYXRpdmUgLi4uKSAuLi4pLCB3aGVyZSB0aGUgb3V0ZXIgbGlz dCBpcyBhIGNvbGxlY3Rpb24KLTs7ICAgb2YgZWxlbWVudHMgZnJvbSBhICcvJyBhbHRlcm5h dGl2ZS4KLShkZWZpbmUgKHBlZy1wYXR0ZXJuLT5kZWZuIGxzdCBmb3Itc3ludGF4KQotICAj YChvciAjLEAobWFwIChsYW1iZGEgKHgpIChwZWctYWx0ZXJuYXRpdmUtPmRlZm4geCBmb3It c3ludGF4KSkKLSAgICAgICAgICAgICAgICAoY29udGV4dC1mbGF0dGVuIChsYW1iZGEgKHgp IChlcT8gKGNhciB4KSAncGVnLWFsdGVybmF0aXZlKSkKLSAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIChjZHIgbHN0KSkpKSkKLQotOzsgbHN0IGhhcyBmb3JtYXQgKCdwZWct YWx0ZXJuYXRpdmUgLi4uKS4KLTs7IEFmdGVyIHRoZSBjb250ZXh0LWZsYXR0ZW4sIChjZHIg bHN0KSBoYXMgdGhlIGZvcm1hdAotOzsgICAoaXRlbSAuLi4pLCB3aGVyZSBlYWNoIGl0ZW0g aGFzIGZvcm1hdCBlaXRoZXIgKCIhIiAuLi4pLCAoIiYiIC4uLiksCi07OyAgIG9yICgncGVn LXN1ZmZpeCAuLi4pLgotKGRlZmluZSAocGVnLWFsdGVybmF0aXZlLT5kZWZuIGxzdCBmb3It c3ludGF4KQotICAjYChhbmQgIyxAKG1hcCAobGFtYmRhICh4KSAocGVnLWJvZHktPmRlZm4g eCBmb3Itc3ludGF4KSkKLSAgICAgICAgICAgICAgICAgKGNvbnRleHQtZmxhdHRlbiAobGFt YmRhICh4KSAob3IgKHN0cmluZz8gKGNhciB4KSkKLSAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIChlcT8gKGNhciB4KSAncGVnLXN1ZmZpeCkpKQotICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChjZHIgbHN0KSkpKSkKLQotOzsgbHN0 IGhhcyB0aGUgZm9ybWF0IGVpdGhlcgotOzsgICAoIiEiICgncGVnLXN1ZmZpeCAuLi4pKSwg KCImIiAoJ3BlZy1zdWZmaXggLi4uKSksIG9yCi07OyAgICAgKCdwZWctc3VmZml4IC4uLiku Ci0oZGVmaW5lIChwZWctYm9keS0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKLSAgICAoY29uZAot ICAgICAgKChlcXVhbD8gKGNhciBsc3QpICImIikKLSAgICAgICAjYChmb2xsb3dlZC1ieSAj LChwZWctc3VmZml4LT5kZWZuIChjYWRyIGxzdCkgZm9yLXN5bnRheCkpKQotICAgICAgKChl cXVhbD8gKGNhciBsc3QpICIhIikKLSAgICAgICAjYChub3QtZm9sbG93ZWQtYnkgIywocGVn LXN1ZmZpeC0+ZGVmbiAoY2FkciBsc3QpIGZvci1zeW50YXgpKSkKLSAgICAgICgoZXE/IChj YXIgbHN0KSAncGVnLXN1ZmZpeCkKLSAgICAgICAocGVnLXN1ZmZpeC0+ZGVmbiBsc3QgZm9y LXN5bnRheCkpCi0gICAgICAoZWxzZSBgKHBlZy1wYXJzZS1ib2R5LWZhaWwgLGxzdCkpKSkK LQotOzsgbHN0IGhhcyBmb3JtYXQgKCdwZWctc3VmZml4IDxwZWctcHJpbWFyeT4gKD8gKC8g IioiICI/IiAiKyIpKSkKLShkZWZpbmUgKHBlZy1zdWZmaXgtPmRlZm4gbHN0IGZvci1zeW50 YXgpCi0gIChsZXQgKChpbm5lci1kZWZuIChwZWctcHJpbWFyeS0+ZGVmbiAoY2FkciBsc3Qp IGZvci1zeW50YXgpKSkKLSAgICAoY29uZAotICAgICAgKChudWxsPyAoY2RkciBsc3QpKQot ICAgICAgIGlubmVyLWRlZm4pCi0gICAgICAoKGVxdWFsPyAoY2FkZHIgbHN0KSAiKiIpCi0g ICAgICAgI2AoKiAjLGlubmVyLWRlZm4pKQotICAgICAgKChlcXVhbD8gKGNhZGRyIGxzdCkg Ij8iKQotICAgICAgICNgKD8gIyxpbm5lci1kZWZuKSkKLSAgICAgICgoZXF1YWw/IChjYWRk ciBsc3QpICIrIikKLSAgICAgICAjYCgrICMsaW5uZXItZGVmbikpKSkpCi0KLTs7IFBhcnNl IGEgcHJpbWFyeS4KLShkZWZpbmUgKHBlZy1wcmltYXJ5LT5kZWZuIGxzdCBmb3Itc3ludGF4 KQotICAobGV0ICgoZWwgKGNhZHIgbHN0KSkpCisgICAgICAgIywoY29tcHJlc3NvciAoRXhw cmVzc2lvbi0+ZGVmbiBleHByZXNzaW9uIGZvci1zeW50YXgpIGZvci1zeW50YXgpKSkpCisK Kzs7IChFeHByZXNzaW9uIChTZXF1ZW5jZSBYKSkKKzs7ICBgLT4gKFgpCis7OyAoRXhwcmVz c2lvbiAoU2VxdWVuY2UgWCkgKFNlcXVlbmNlIFkpKQorOzsgIGAtPiAob3IgWCBZKQorOzsg KEV4cHJlc3Npb24gKFNlcXVlbmNlIFgpICgoU2VxdWVuY2UgWSkgKFNlcXVlbmNlIFopIC4u LikpCis7OyAgYC0+IChvciBYIFkgWiAuLi4pCisoZGVmaW5lIChFeHByZXNzaW9uLT5kZWZu IGxzdCBmb3Itc3ludGF4KQorICAobGV0ICgoZmlyc3Qtc2VxdWVuY2UgKHNlY29uZCBsc3Qp KQorICAgICAgICAocmVzdCAgICAgICAgICAgKGNkZHIgIGxzdCkpKQorICAgICNgKG9yICMs KFNlcXVlbmNlLT5kZWZuIGZpcnN0LXNlcXVlbmNlIGZvci1zeW50YXgpCisgICAgICAgICAg IyxAKG1hcCAobGFtYmRhICh4KQorICAgICAgICAgICAgICAgICAgICAoU2VxdWVuY2UtPmRl Zm4geCBmb3Itc3ludGF4KSkKKyAgICAgICAgICAgICAgICAgIChrZXl3b3JkLWZsYXR0ZW4g JyhTZXF1ZW5jZSkgcmVzdCkpKSkpCisKKworKGRlZmluZSAoU2VxdWVuY2UtPmRlZm4gbHN0 IGZvci1zeW50YXgpCisgICNgKGFuZCAjLEAobWFwIChsYW1iZGEgKHgpIChQcmVmaXgtPmRl Zm4geCBmb3Itc3ludGF4KSkgKGNkciBsc3QpKSkpCisKKworOzsgKFByZWZpeCAoU3VmZml4 IC4uLikpCis7OyAgYC0+ICguLi4pCis7OyAoUHJlZml4IChOT1QgIiEiKSAoU3VmZml4IC4u LikpCis7OyAgYC0+IChub3QtZm9sbG93ZWQtYnkgLi4uKQorOzsgKFByZWZpeCAoQU5EICIm IikgKFN1ZmZpeCAuLi4pKQorOzsgIGAtPiAoZm9sbG93ZWQtYnkgLi4uKQorKGRlZmluZSAo UHJlZml4LT5kZWZuIGxzdCBmb3Itc3ludGF4KQorICAobGV0ICgoc3VmZml4IChzZWNvbmQg bHN0KSkpCisgICAgKGNhc2UgKGNhciBzdWZmaXgpCisgICAgICAoJ0FORCAjYChmb2xsb3dl ZC1ieSAjLChTdWZmaXgtPmRlZm4gKHRoaXJkIGxzdCkgZm9yLXN5bnRheCkpKQorICAgICAg KCdOT1QgI2Aobm90LWZvbGxvd2VkLWJ5ICMsKFN1ZmZpeC0+ZGVmbiAodGhpcmQgbHN0KSBm b3Itc3ludGF4KSkpCisgICAgICAoZWxzZSAoU3VmZml4LT5kZWZuIHN1ZmZpeCBmb3Itc3lu dGF4KSkpKSkKKworOzsgKFN1ZmZpeCAoUHJpbWFyeSAuLi4pKQorOzsgIGAtPiAoLi4uKQor OzsgKFN1ZmZpeCAoUHJpbWFyeSAuLi4pIChTVEFSICIqIikpCis7OyAgYC0+ICgqIC4uLikK Kzs7IChTdWZmaXggKFByaW1hcnkgLi4uKSAoUVVFU1RJT04gIj8iKSkKKzs7ICBgLT4gKD8g Li4uKQorOzsgKFN1ZmZpeCAoUHJpbWFyeSAuLi4pIChQTFVTICIrIikpCis7OyAgYC0+ICgr IC4uLikKKyhkZWZpbmUgKFN1ZmZpeC0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKKyAgKGxldCog KChwcmltYXJ5IChzZWNvbmQgbHN0KSkKKyAgICAgICAgIChvdXQgICAgIChQcmltYXJ5LT5k ZWZuIHByaW1hcnkgZm9yLXN5bnRheCkpCisgICAgICAgICAoZXh0cmEgICAoY2RkciBsc3Qp KSkKKyAgICAoaWYgKG51bGw/IGV4dHJhKQorICAgICAgb3V0CisgICAgICAoY2FzZSAoY2Fh ciBleHRyYSkKKyAgICAgICAgKCdRVUVTVElPTiAjYCg/ICMsb3V0KSkKKyAgICAgICAgKCdT VEFSICAgICAjYCgqICMsb3V0KSkKKyAgICAgICAgKCdQTFVTICAgICAjYCgrICMsb3V0KSkp KSkpCisKKyhkZWZpbmUgKFByaW1hcnktPmRlZm4gbHN0IGZvci1zeW50YXgpCisgIChsZXQg KCh2YWx1ZSAoc2Vjb25kIGxzdCkpKQorICAgIChjYXNlIChjYXIgdmFsdWUpCisgICAgICAo J0RPVCAgICAgICAgIydwZWctYW55KQorICAgICAgKCdJZGVudGlmaWVyIChJZGVudGlmaWVy LT5kZWZuIHZhbHVlIGZvci1zeW50YXgpKQorICAgICAgKCdFeHByZXNzaW9uIChFeHByZXNz aW9uLT5kZWZuIHZhbHVlIGZvci1zeW50YXgpKQorICAgICAgKCdMaXRlcmFsICAgIChMaXRl cmFsLT5kZWZuIHZhbHVlIGZvci1zeW50YXgpKQorICAgICAgKCdDbGFzcyAgICAgIChDbGFz cy0+ZGVmbiB2YWx1ZSBmb3Itc3ludGF4KSkpKSkKKworOzsgKElkZW50aWZpZXIgImhlbGxv IikKKzs7ICBgLT4gaGVsbG8KKyhkZWZpbmUgKElkZW50aWZpZXItPmRlZm4gbHN0IGZvci1z eW50YXgpCisgIChkYXR1bS0+c3ludGF4IGZvci1zeW50YXggKHN0cmluZy0+c3ltYm9sIChz ZWNvbmQgbHN0KSkpKQorCis7OyAoTGl0ZXJhbCAoQ2hhciAiYSIpIChDaGFyICJiIikgKENo YXIgImMiKSkKKzs7ICBgLT4gImFiYyIKKyhkZWZpbmUgKExpdGVyYWwtPmRlZm4gbHN0IGZv ci1zeW50YXgpCisgIChhcHBseSBzdHJpbmcgKG1hcCAobGFtYmRhICh4KSAoQ2hhci0+ZGVm biB4IGZvci1zeW50YXgpKSAoY2RyIGxzdCkpKSkKKworOzsgVE9ETzogZW1wdHkgQ2xhc3Mg Y2FuIGhhcHBlbjogYFtdYCwgYnV0IHdoYXQgZG9lcyBpdCByZXByZXNlbnQ/Cis7OyAoQ2xh c3MgLi4uKQorOzsgIGAtPiAob3IgLi4uKQorKGRlZmluZSAoQ2xhc3MtPmRlZm4gbHN0IGZv ci1zeW50YXgpCisgICNgKG9yICMsQChtYXAgKGxhbWJkYSAoeCkgKFJhbmdlLT5kZWZuIHgg Zm9yLXN5bnRheCkpCisgICAgICAgICAgICAgICAgKGNkciBsc3QpKSkpCisKKzs7IEZvciBv bmUgY2hhcmFjdGVyOgorOzsgKFJhbmdlIChDaGFyICJhIikpCis7OyAgYC0+ICJhIgorOzsg T3IgZm9yIGEgcmFuZ2U6Cis7OyAoUmFuZ2UgKENoYXIgImEiKSAoQ2hhciAiYiIpKQorOzsg IGAtPiAocmFuZ2UgI1xhICNcYikKKyhkZWZpbmUgKFJhbmdlLT5kZWZuIGxzdCBmb3Itc3lu dGF4KQogICAoY29uZAotICAgKChsaXN0PyBlbCkKLSAgICAoY29uZAotICAgICAoKGVxPyAo Y2FyIGVsKSAncGVnLWxpdGVyYWwpCi0gICAgICAocGVnLWxpdGVyYWwtPmRlZm4gZWwgZm9y LXN5bnRheCkpCi0gICAgICgoZXE/IChjYXIgZWwpICdwZWctY2hhcmNsYXNzKQotICAgICAg KHBlZy1jaGFyY2xhc3MtPmRlZm4gZWwgZm9yLXN5bnRheCkpCi0gICAgICgoZXE/IChjYXIg ZWwpICdwZWctbm9udGVybWluYWwpCi0gICAgICAoZGF0dW0tPnN5bnRheCBmb3Itc3ludGF4 IChzdHJpbmctPnN5bWJvbCAoY2FkciBlbCkpKSkpKQotICAgKChzdHJpbmc/IGVsKQorICAg ICgoPSAyIChsZW5ndGggbHN0KSkKKyAgICAgKHNlY29uZCAoc2Vjb25kIGxzdCkpKQorICAg ICgoPSAzIChsZW5ndGggbHN0KSkKKyAgICAgI2AocmFuZ2UKKyAgICAgICAgICMsKENoYXIt PmRlZm4gKHNlY29uZCBsc3QpIGZvci1zeW50YXgpCisgICAgICAgICAjLChDaGFyLT5kZWZu ICh0aGlyZCBsc3QpIGZvci1zeW50YXgpKSkpKQorCis7OyAoQ2hhciAiYSIpCis7OyAgYC0+ ICNcYQorOzsgKENoYXIgIlxcbiIpCis7OyAgYC0+ICNcbmV3bGluZQorOzsgKENoYXIgIlxc MTM1IikKKzs7ICBgLT4gI1xdCisoZGVmaW5lIChDaGFyLT5kZWZuIGxzdCBmb3Itc3ludGF4 KQorICAobGV0KiAoKGNoYXJzdHIgKHNlY29uZCBsc3QpKQorICAgICAgICAgKGZpcnN0ICAg KHN0cmluZy1yZWYgY2hhcnN0ciAwKSkpCiAgICAgKGNvbmQKLSAgICAgKChlcXVhbD8gZWwg IigiKQotICAgICAgKHBlZy1wYXR0ZXJuLT5kZWZuIChjYWRkciBsc3QpIGZvci1zeW50YXgp KQotICAgICAoKGVxdWFsPyBlbCAiLiIpCi0gICAgICAoZGF0dW0tPnN5bnRheCBmb3Itc3lu dGF4ICdwZWctYW55KSkKLSAgICAgKGVsc2UgKGRhdHVtLT5zeW50YXggZm9yLXN5bnRheAot ICAgICAgICAgICAgICAgICAgICAgICAgICBgKHBlZy1wYXJzZS1hbnkgdW5rbm93bi1zdHJp bmcgLGxzdCkpKSkpCi0gICAoZWxzZSAoZGF0dW0tPnN5bnRheCBmb3Itc3ludGF4Ci0gICAg ICAgICAgICAgICAgICAgICAgICBgKHBlZy1wYXJzZS1hbnkgdW5rbm93bi1lbCAsbHN0KSkp KSkpCi0KLTs7IFRyaW1zIGNoYXJhY3RlcnMgb2ZmIHRoZSBmcm9udCBhbmQgZW5kIG9mIFNU Ui4KLTs7ICh0cmltLTFjaGFycyAiJ2FiJyIpIC0+ICJhYiIKLShkZWZpbmUgKHRyaW0tMWNo YXJzIHN0cikgKHN1YnN0cmluZyBzdHIgMSAoLSAoc3RyaW5nLWxlbmd0aCBzdHIpIDEpKSkK LQotOzsgUGFyc2VzIGEgbGl0ZXJhbC4KLShkZWZpbmUgKHBlZy1saXRlcmFsLT5kZWZuIGxz dCBmb3Itc3ludGF4KQotICAoZGF0dW0tPnN5bnRheCBmb3Itc3ludGF4ICh0cmltLTFjaGFy cyAoY2FkciBsc3QpKSkpCi0KLTs7IFBhcnNlcyBhIGNoYXJjbGFzcy4KLShkZWZpbmUgKHBl Zy1jaGFyY2xhc3MtPmRlZm4gbHN0IGZvci1zeW50YXgpCi0gICNgKG9yCi0gICAgICMsQCht YXAKLSAgICAgICAgIChsYW1iZGEgKGNjKQotICAgICAgICAgICAoY29uZAotICAgICAgICAg ICAgKChlcT8gKGNhciBjYykgJ2NoYXJjbGFzcy1yYW5nZSkKLSAgICAgICAgICAgICAjYChy YW5nZSAjLChkYXR1bS0+c3ludGF4Ci0gICAgICAgICAgICAgICAgICAgICAgICAgZm9yLXN5 bnRheAotICAgICAgICAgICAgICAgICAgICAgICAgIChzdHJpbmctcmVmIChjYWRyIGNjKSAw KSkKLSAgICAgICAgICAgICAgICAgICAgICAjLChkYXR1bS0+c3ludGF4Ci0gICAgICAgICAg ICAgICAgICAgICAgICAgZm9yLXN5bnRheAotICAgICAgICAgICAgICAgICAgICAgICAgIChz dHJpbmctcmVmIChjYWRyIGNjKSAyKSkpKQotICAgICAgICAgICAgKChlcT8gKGNhciBjYykg J2NoYXJjbGFzcy1zaW5nbGUpCi0gICAgICAgICAgICAgKGRhdHVtLT5zeW50YXggZm9yLXN5 bnRheCAoY2FkciBjYykpKSkpCi0gICAgICAgICAoY29udGV4dC1mbGF0dGVuCi0gICAgICAg ICAgKGxhbWJkYSAoeCkgKG9yIChlcT8gKGNhciB4KSAnY2hhcmNsYXNzLXJhbmdlKQotICAg ICAgICAgICAgICAgICAgICAgICAgICAoZXE/IChjYXIgeCkgJ2NoYXJjbGFzcy1zaW5nbGUp KSkKLSAgICAgICAgICAoY2RyIGxzdCkpKSkpCisgICAgICAoKD0gMSAoc3RyaW5nLWxlbmd0 aCBjaGFyc3RyKSkgZmlyc3QpCisgICAgICAoKGNoYXItbnVtZXJpYz8gKHN0cmluZy1yZWYg Y2hhcnN0ciAxKSkKKyAgICAgICAoaW50ZWdlci0+Y2hhcgorICAgICAgICAgKHJlZHVjZSAr IDAKKyAgICAgICAgICAgICAgICAgKG1hcAorICAgICAgICAgICAgICAgICAgIChsYW1iZGEg KHggeSkKKyAgICAgICAgICAgICAgICAgICAgICgqICgtIChjaGFyLT5pbnRlZ2VyIHgpIChj aGFyLT5pbnRlZ2VyICNcMCkpIHkpKQorICAgICAgICAgICAgICAgICAgIChyZXZlcnNlIChz dHJpbmctPmxpc3QgY2hhcnN0ciAxKSkKKyAgICAgICAgICAgICAgICAgICAnKDEgOCA2NCkp KSkpCisgICAgICAoZWxzZQorICAgICAgICAoY2FzZSAoc3RyaW5nLXJlZiBjaGFyc3RyIDEp CisgICAgICAgICAgKCgjXG4pICNcbmV3bGluZSkKKyAgICAgICAgICAoKCNccikgI1xyZXR1 cm4pCisgICAgICAgICAgKCgjXHQpICNcdGFiKQorICAgICAgICAgICgoI1wnKSAjXCcpCisg ICAgICAgICAgKCgjXF0pICNcXSkKKyAgICAgICAgICAoKCNcXCkgI1xcKQorICAgICAgICAg ICgoI1xbKSAjXFspKSkpKSkKKworKGRlZmluZSBwZWctZ3JhbW1hciBHcmFtbWFyKQorCis7 OyBNYWNybyB3cmFwcGVyIGZvciBQRUctUEFSU0VSLiAgUGFyc2VzIFBFRyBncmFtbWFycyBl eHByZXNzZWQgYXMgc3RyaW5ncyBhbmQKKzs7IGRlZmluZXMgYWxsIHRoZSBhcHByb3ByaWF0 ZSBub250ZXJtaW5hbHMuCisoZGVmaW5lLXN5bnRheCBkZWZpbmUtcGVnLXN0cmluZy1wYXR0 ZXJucworICAobGFtYmRhICh4KQorICAgIChzeW50YXgtY2FzZSB4ICgpCisgICAgICAoKF8g c3RyKQorICAgICAgIChwZWctcGFyc2VyIChzeW50YXgtPmRhdHVtICMnc3RyKSB4KSkpKSkK IAogOzsgQ29tcHJlc3NlcyBhIGxpc3QgdG8gc2F2ZSB0aGUgb3B0aW1pemVyIHdvcmsuCiA7 OyBlLmcuIChvciAoYW5kIGEpKSAtPiBhCkBAIC0yNjMsMTEgKzM3NCwxMCBAQCBSQiA8ICdd JwogICAgICAobGV0ICgoc3RyaW5nIChzeW50YXgtPmRhdHVtICMnc3RyLXN0eCkpKQogICAg ICAgIChjb21waWxlLXBlZy1wYXR0ZXJuCiAgICAgICAgIChjb21wcmVzc29yCi0gICAgICAg ICAocGVnLXBhdHRlcm4tPmRlZm4KLSAgICAgICAgICAocGVnOnRyZWUgKG1hdGNoLXBhdHRl cm4gcGVnLXBhdHRlcm4gc3RyaW5nKSkgIydzdHItc3R4KQorICAgICAgICAgKEV4cHJlc3Np b24tPmRlZm4KKyAgICAgICAgICAocGVnOnRyZWUgKG1hdGNoLXBhdHRlcm4gRXhwcmVzc2lv biBzdHJpbmcpKSAjJ3N0ci1zdHgpCiAgICAgICAgICAjJ3N0ci1zdHgpCiAgICAgICAgIChp ZiAoZXE/IGFjY3VtICdhbGwpICdib2R5IGFjY3VtKSkpKQogICAgICAoZWxzZSAoZXJyb3Ig IkJhZCBlbWJlZGRlZCBQRUcgc3RyaW5nIiBhcmdzKSkpKQogCiAoYWRkLXBlZy1jb21waWxl ciEgJ3BlZyBwZWctc3RyaW5nLWNvbXBpbGUpCi0KZGlmZiAtLWdpdCBhL3Rlc3Qtc3VpdGUv dGVzdHMvcGVnLnRlc3QgYi90ZXN0LXN1aXRlL3Rlc3RzL3BlZy50ZXN0CmluZGV4IGY1MTY1 NzFlOC4uNTU2MTQ1ZTcyIDEwMDY0NAotLS0gYS90ZXN0LXN1aXRlL3Rlc3RzL3BlZy50ZXN0 CisrKyBiL3Rlc3Qtc3VpdGUvdGVzdHMvcGVnLnRlc3QKQEAgLTI4LDE3ICsyOCwyNSBAQAog OzsgdGhlIG5vbnRlcm1pbmFscyBkZWZpbmVkIGluIHRoZSBQRUcgcGFyc2VyIHdyaXR0ZW4g d2l0aAogOzsgUy1leHByZXNzaW9ucy4KIChkZWZpbmUgZ3JhbW1hci1tYXBwaW5nCi0gICco KGdyYW1tYXIgcGVnLWdyYW1tYXIpCi0gICAgKHBhdHRlcm4gcGVnLXBhdHRlcm4pCi0gICAg KGFsdGVybmF0aXZlIHBlZy1hbHRlcm5hdGl2ZSkKLSAgICAoc3VmZml4IHBlZy1zdWZmaXgp Ci0gICAgKHByaW1hcnkgcGVnLXByaW1hcnkpCi0gICAgKGxpdGVyYWwgcGVnLWxpdGVyYWwp Ci0gICAgKGNoYXJjbGFzcyBwZWctY2hhcmNsYXNzKQotICAgIChDQ3JhbmdlIGNoYXJjbGFz cy1yYW5nZSkKLSAgICAoQ0NzaW5nbGUgY2hhcmNsYXNzLXNpbmdsZSkKLSAgICAobm9udGVy bWluYWwgcGVnLW5vbnRlcm1pbmFsKQotICAgIChzcCBwZWctc3ApKSkKKyAgJygoR3JhbW1h ciBHcmFtbWFyKQorICAgIChEZWZpbml0aW9uIERlZmluaXRpb24pCisgICAgKEV4cHJlc3Np b24gRXhwcmVzc2lvbikKKyAgICAoU2VxdWVuY2UgU2VxdWVuY2UpCisgICAgKFByZWZpeCBQ cmVmaXgpCisgICAgKFN1ZmZpeCBTdWZmaXgpCisgICAgKFByaW1hcnkgUHJpbWFyeSkKKyAg ICAoSWRlbnRpZmllciBJZGVudGlmaWVyKQorICAgIChMaXRlcmFsIExpdGVyYWwpCisgICAg KENsYXNzIENsYXNzKQorICAgIChSYW5nZSBSYW5nZSkKKyAgICAoQ2hhciBDaGFyKQorICAg IChMRUZUQVJST1cgTEVGVEFSUk9XKQorICAgIChBTkQgQU5EKQorICAgIChOT1QgTk9UKQor ICAgIChRVUVTVElPTiBRVUVTVElPTikKKyAgICAoU1RBUiBTVEFSKQorICAgIChQTFVTIFBM VVMpCisgICAgKERPVCBET1QpKSkKIAogOzsgVHJhbnNmb3JtcyB0aGUgbm9udGVybWluYWxz IGRlZmluZWQgaW4gdGhlIFBFRyBwYXJzZXIgd3JpdHRlbiBhcyBhIFBFRyB0byB0aGUgbm9u dGVybWluYWxzIGRlZmluZWQgaW4gdGhlIFBFRyBwYXJzZXIgd3JpdHRlbiB3aXRoIFMtZXhw cmVzc2lvbnMuCiAoZGVmaW5lIChncmFtbWFyLXRyYW5zZm9ybSB4KQpAQCAtNjksNyArNzcs NyBAQAogICAgIChwZWc6dHJlZSAobWF0Y2gtcGF0dGVybiAoQEAgKGljZS05IHBlZykgcGVn LWdyYW1tYXIpIChAQCAoaWNlLTkgcGVnKSBwZWctYXMtcGVnKSkpCiAgICAgKHRyZWUtbWFw CiAgICAgIGdyYW1tYXItdHJhbnNmb3JtCi0gICAgIChwZWc6dHJlZSAobWF0Y2gtcGF0dGVy biBncmFtbWFyIChAQCAoaWNlLTkgcGVnKSBwZWctYXMtcGVnKSkpKSkpKQorICAgICAocGVn OnRyZWUgKG1hdGNoLXBhdHRlcm4gKEBAIChpY2UtOSBwZWcpIHBlZy1ncmFtbWFyKSAoQEAg KGljZS05IHBlZykgcGVnLWFzLXBlZykpKSkpKSkKIAogOzsgQSBncmFtbWFyIGZvciBwYXNj YWwtc3R5bGUgY29tbWVudHMgZnJvbSBXaWtpcGVkaWEuCiAoZGVmaW5lIGNvbW1lbnQtZ3Jh bW1hcgotLSAKMi40Ni4wCgo= --------------3N0zblOVoqBRwSKdoRkb0HaK Content-Type: text/x-patch; charset=UTF-8; name="v3-0002-PEG-Add-support-for-not-in-range-and.patch" Content-Disposition: attachment; filename="v3-0002-PEG-Add-support-for-not-in-range-and.patch" Content-Transfer-Encoding: base64 RnJvbSA2NGExN2JlMDg1ODE0NjVkMTExODViNGEwY2E2MzYzNTRkMmY5NDRjIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBFa2FpdHogWmFycmFnYSA8ZWthaXR6QGVsZW5xLnRl Y2g+CkRhdGU6IEZyaSwgMTEgT2N0IDIwMjQgMTQ6MjQ6MzAgKzAyMDAKU3ViamVjdDogW1BB VENIIHYzIDIvMl0gUEVHOiBBZGQgc3VwcG9ydCBmb3IgYG5vdC1pbi1yYW5nZWAgYW5kIFte Li4uXQoKTW9kZXJuIFBFRyBzdXBwb3J0cyBpbnZlcnNlZCBjbGFzcyBsaWtlIGBbXmEtel1g IHRoYXQgd291bGQgZ2V0IGFueQpjaGFyYWN0ZXIgbm90IGluIHRoZSBgYS16YCByYW5nZS4g VGhpcyBjb21taXQgYWRkcyBzdXBwb3J0IGZvciB0aGF0IGFuZAphbHNvIGZvciBhIG5ldyBg bm90LWluLXJhbmdlYCBQRUcgcGF0dGVybiBmb3Igc2NoZW1lLgoKKiBtb2R1bGUvaWNlLTkv cGVnL2NvZGVnZW4uc2NtIChjZy1ub3QtaW4tcmFuZ2UpOiBOZXcgZnVuY3Rpb24uCiogbW9k dWxlL2ljZS05L3BlZy9zdHJpbmctcGVnLnNjbTogQWRkIHN1cHBvcnQgZm9yIGBbXi4uLl1g CiogdGVzdC1zdWl0ZS90ZXN0cy9wZWcudGVzdDogVGVzdCBpdC4KKiBkb2MvcmVmL2FwaS1w ZWcudGV4aTogRG9jdW1lbnQgYWNjb3JkaW5nbHkuCi0tLQogZG9jL3JlZi9hcGktcGVnLnRl eGkgICAgICAgICAgICB8ICA4ICsrKysrKysKIG1vZHVsZS9pY2UtOS9wZWcvY29kZWdlbi5z Y20gICAgfCAyMiArKysrKysrKysrKysrKysrKysrCiBtb2R1bGUvaWNlLTkvcGVnL3N0cmlu Zy1wZWcuc2NtIHwgMzkgKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tCiB0ZXN0 LXN1aXRlL3Rlc3RzL3BlZy50ZXN0ICAgICAgIHwgIDYgKysrKy0KIDQgZmlsZXMgY2hhbmdl ZCwgNzAgaW5zZXJ0aW9ucygrKSwgNSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kb2Mv cmVmL2FwaS1wZWcudGV4aSBiL2RvYy9yZWYvYXBpLXBlZy50ZXhpCmluZGV4IDg0YTllNmM2 Yi4uZWRiMDkwYjIwIDEwMDY0NAotLS0gYS9kb2MvcmVmL2FwaS1wZWcudGV4aQorKysgYi9k b2MvcmVmL2FwaS1wZWcudGV4aQpAQCAtMTQ3LDYgKzE0NywxNCBAQCBQYXJzZXMgYW55IGNo YXJhY3RlciBmYWxsaW5nIGJldHdlZW4gQHZhcnthfSBhbmQgQHZhcnt6fS4KIEBjb2Rleyhy YW5nZSAjXGEgI1x6KX0KIEBlbmQgZGVmdHAKIAorQGRlZnRwIHtQRUcgUGF0dGVybn0ge2lu dmVyc2UgcmFuZ2Ugb2YgY2hhcmFjdGVyc30gYSB6CitQYXJzZXMgYW55IGNoYXJhY3RlciBu b3QgZmFsbGluZyBiZXR3ZWVuIEB2YXJ7YX0gYW5kIEB2YXJ7en0uCisKK0Bjb2RleyJbXmEt el0ifQorCitAY29kZXsobm90LWluLXJhbmdlICNcYSAjXHopfQorQGVuZCBkZWZ0cAorCiBF eGFtcGxlOgogCiBAZXhhbXBsZQpkaWZmIC0tZ2l0IGEvbW9kdWxlL2ljZS05L3BlZy9jb2Rl Z2VuLnNjbSBiL21vZHVsZS9pY2UtOS9wZWcvY29kZWdlbi5zY20KaW5kZXggZDgwYzNlODQ5 Li44MjM2N2VmNTUgMTAwNjQ0Ci0tLSBhL21vZHVsZS9pY2UtOS9wZWcvY29kZWdlbi5zY20K KysrIGIvbW9kdWxlL2ljZS05L3BlZy9jb2RlZ2VuLnNjbQpAQCAtMTQwLDYgKzE0MCwyNyBA QCByZXR1cm4gRVhQLiIKICAgICAgICAgICAgICAgICAgICAgICAgICAoKG5vbmUpICNgKGxp c3QgKDErIHBvcykgJygpKSkKICAgICAgICAgICAgICAgICAgICAgICAgICAoZWxzZSAoZXJy b3IgImJhZCBhY2N1bSIgYWNjdW0pKSkpKSkpKSkpCiAKKzs7IEdlbmVyYXRlcyBjb2RlIGZv ciBtYXRjaGluZyBhIHJhbmdlIG9mIGNoYXJhY3RlcnMgbm90IGJldHdlZW4gc3RhcnQgYW5k IGVuZC4KKzs7IEUuZy46IChjZy1ub3QtaW4tcmFuZ2Ugc3ludGF4ICNcYSAjXHogJ2JvZHkp CisoZGVmaW5lIChjZy1ub3QtaW4tcmFuZ2UgcGF0IGFjY3VtKQorICAoc3ludGF4LWNhc2Ug cGF0ICgpCisgICAgKChzdGFydCBlbmQpCisgICAgIChpZiAobm90IChhbmQgKGNoYXI/IChz eW50YXgtPmRhdHVtICMnc3RhcnQpKQorICAgICAgICAgICAgICAgICAgIChjaGFyPyAoc3lu dGF4LT5kYXR1bSAjJ2VuZCkpKSkKKyAgICAgICAgIChlcnJvciAicmFuZ2UgUEVHIHNob3Vs ZCBoYXZlIGNoYXJhY3RlcnMgYWZ0ZXIgaXQ7IGluc3RlYWQgZ290IgorICAgICAgICAgICAg ICAgICMnc3RhcnQgIydlbmQpKQorICAgICAjYChsYW1iZGEgKHN0ciBsZW4gcG9zKQorICAg ICAgICAgKGFuZCAoPCBwb3MgbGVuKQorICAgICAgICAgICAgICAobGV0ICgoYyAoc3RyaW5n LXJlZiBzdHIgcG9zKSkpCisgICAgICAgICAgICAgICAgKGFuZCAob3IgKGNoYXI8PyBjIHN0 YXJ0KSAoY2hhcj4/IGMgZW5kKSkKKyAgICAgICAgICAgICAgICAgICAgICMsKGNhc2UgYWNj dW0KKyAgICAgICAgICAgICAgICAgICAgICAgICAoKGFsbCkgI2AobGlzdCAoMSsgcG9zKQor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChsaXN0ICdjZy1ub3Qt aW4tcmFuZ2UgKHN0cmluZyBjKSkpKQorICAgICAgICAgICAgICAgICAgICAgICAgICgobmFt ZSkgI2AobGlzdCAoMSsgcG9zKSAnY2ctbm90LWluLXJhbmdlKSkKKyAgICAgICAgICAgICAg ICAgICAgICAgICAoKGJvZHkpICNgKGxpc3QgKDErIHBvcykgKHN0cmluZyBjKSkpCisgICAg ICAgICAgICAgICAgICAgICAgICAgKChub25lKSAjYChsaXN0ICgxKyBwb3MpICcoKSkpCisg ICAgICAgICAgICAgICAgICAgICAgICAgKGVsc2UgKGVycm9yICJiYWQgYWNjdW0iIGFjY3Vt KSkpKSkpKSkpKQorCiA7OyBHZW5lcmF0ZSBjb2RlIHRvIG1hdGNoIGEgcGF0dGVybiBhbmQg ZG8gbm90aGluZyB3aXRoIHRoZSByZXN1bHQKIChkZWZpbmUgKGNnLWlnbm9yZSBwYXQgYWNj dW0pCiAgIChzeW50YXgtY2FzZSBwYXQgKCkKQEAgLTMwNCw2ICszMjUsNyBAQCByZXR1cm4g RVhQLiIKICAgICAgICAgKGFzc3Etc2V0ISBwZWctY29tcGlsZXItYWxpc3Qgc3ltYm9sIGZ1 bmN0aW9uKSkpCiAKIChhZGQtcGVnLWNvbXBpbGVyISAncmFuZ2UgY2ctcmFuZ2UpCisoYWRk LXBlZy1jb21waWxlciEgJ25vdC1pbi1yYW5nZSBjZy1ub3QtaW4tcmFuZ2UpCiAoYWRkLXBl Zy1jb21waWxlciEgJ2lnbm9yZSBjZy1pZ25vcmUpCiAoYWRkLXBlZy1jb21waWxlciEgJ2Nh cHR1cmUgY2ctY2FwdHVyZSkKIChhZGQtcGVnLWNvbXBpbGVyISAnYW5kIGNnLWFuZCkKZGlm ZiAtLWdpdCBhL21vZHVsZS9pY2UtOS9wZWcvc3RyaW5nLXBlZy5zY20gYi9tb2R1bGUvaWNl LTkvcGVnL3N0cmluZy1wZWcuc2NtCmluZGV4IGY2ODg2NTNlZi4uMmQyZjk3MmZmIDEwMDY0 NAotLS0gYS9tb2R1bGUvaWNlLTkvcGVnL3N0cmluZy1wZWcuc2NtCisrKyBiL21vZHVsZS9p Y2UtOS9wZWcvc3RyaW5nLXBlZy5zY20KQEAgLTUzLDcgKzUzLDcgQEAgUHJlZml4IDwtLSAo QU5EIC8gTk9UKT8gU3VmZml4CiBTdWZmaXggPC0tIFByaW1hcnkgKFFVRVNUSU9OIC8gU1RB UiAvIFBMVVMpPwogUHJpbWFyeSA8LS0gSWRlbnRpZmllciAhTEVGVEFSUk9XCiAgICAgICAg ICAgIC8gT1BFTiBFeHByZXNzaW9uIENMT1NFCi0gICAgICAgICAgIC8gTGl0ZXJhbCAvIENs YXNzIC8gRE9UCisgICAgICAgICAgIC8gTGl0ZXJhbCAvIENsYXNzIC8gTm90SW5DbGFzcyAv IERPVAogCiAjIExleGljYWwgc3ludGF4CiBJZGVudGlmaWVyIDwtLSBJZGVudFN0YXJ0IElk ZW50Q29udCogU3BhY2luZwpAQCAtNjMsNyArNjMsOCBAQCBJZGVudENvbnQgPC0gSWRlbnRT dGFydCAvIFswLTldCiAKIExpdGVyYWwgPC0tIFNRVU9URSAoIVNRVU9URSBDaGFyKSogU1FV T1RFIFNwYWNpbmcKICAgICAgICAgLyBEUVVPVEUgKCFEUVVPVEUgQ2hhcikqIERRVU9URSBT cGFjaW5nCi1DbGFzcyA8LS0gJ1snICghJ10nIFJhbmdlKSogJ10nIFNwYWNpbmcKK05vdElu Q2xhc3MgPC0tICdbJyBOT1RJTiAgKCEnXScgUmFuZ2UpKiAnXScgU3BhY2luZworQ2xhc3Mg PC0tICdbJyAhTk9USU4gKCEnXScgUmFuZ2UpKiAnXScgU3BhY2luZwogUmFuZ2UgPC0tIENo YXIgJy0nIENoYXIgLyBDaGFyCiBDaGFyIDwtLSAnXFxcXCcgW25ydCdcIlxcW1xcXVxcXFxd CiAgICAgICAgLyAnXFxcXCcgWzAtN11bMC03XVswLTddCkBAIC03Niw2ICs3Nyw3IEBAIFNR VU9URSA8LS0gWyddCiBEUVVPVEUgPC0tIFtcIl0KIE9QRU5CUkFDS0VUIDwgJ1snCiBDTE9T RUJSQUNLRVQgPCAnXScKK05PVElOIDwgJ14nCiBTTEFTSCA8ICcvJyBTcGFjaW5nCiBBTkQg PC0tICcmJyBTcGFjaW5nCiBOT1QgPC0tICchJyBTcGFjaW5nCkBAIC0xMjAsNiArMTIyLDcg QEAgRW5kT2ZGaWxlIDwgIS4KICAgICAgIChhbmQgT1BFTiBFeHByZXNzaW9uIENMT1NFKQog ICAgICAgTGl0ZXJhbAogICAgICAgQ2xhc3MKKyAgICAgIE5vdEluQ2xhc3MKICAgICAgIERP VCkpCiAoZGVmaW5lLXNleHAtcGFyc2VyIElkZW50aWZpZXIgYWxsCiAgIChhbmQgSWRlbnRT dGFydCAoKiBJZGVudENvbnQpIFNwYWNpbmcpKQpAQCAtMTMxLDcgKzEzNCwxMSBAQCBFbmRP ZkZpbGUgPCAhLgogICAob3IgKGFuZCBTUVVPVEUgKCogKGFuZCAobm90LWZvbGxvd2VkLWJ5 IFNRVU9URSkgQ2hhcikpIFNRVU9URSBTcGFjaW5nKQogICAgICAgKGFuZCBEUVVPVEUgKCog KGFuZCAobm90LWZvbGxvd2VkLWJ5IERRVU9URSkgQ2hhcikpIERRVU9URSBTcGFjaW5nKSkp CiAoZGVmaW5lLXNleHAtcGFyc2VyIENsYXNzIGFsbAotICAoYW5kIE9QRU5CUkFDS0VUICgq IChhbmQgKG5vdC1mb2xsb3dlZC1ieSBDTE9TRUJSQUNLRVQpIFJhbmdlKSkgQ0xPU0VCUkFD S0VUIFNwYWNpbmcpKQorICAoYW5kIE9QRU5CUkFDS0VUIChub3QtZm9sbG93ZWQtYnkgTk9U SU4pCisgICAgICAgKCogKGFuZCAobm90LWZvbGxvd2VkLWJ5IENMT1NFQlJBQ0tFVCkgUmFu Z2UpKSBDTE9TRUJSQUNLRVQgU3BhY2luZykpCisoZGVmaW5lLXNleHAtcGFyc2VyIE5vdElu Q2xhc3MgYWxsCisgIChhbmQgT1BFTkJSQUNLRVQgTk9USU4KKyAgICAgICAoKiAoYW5kIChu b3QtZm9sbG93ZWQtYnkgQ0xPU0VCUkFDS0VUKSBSYW5nZSkpIENMT1NFQlJBQ0tFVCBTcGFj aW5nKSkKIChkZWZpbmUtc2V4cC1wYXJzZXIgUmFuZ2UgYWxsCiAgIChvciAoYW5kIENoYXIg REFTSCBDaGFyKSBDaGFyKSkKIChkZWZpbmUtc2V4cC1wYXJzZXIgQ2hhciBhbGwKQEAgLTE0 MSw2ICsxNDgsOCBAQCBFbmRPZkZpbGUgPCAhLgogICAgICAgKGFuZCAobm90LWZvbGxvd2Vk LWJ5ICJcXCIpIHBlZy1hbnkpKSkKIChkZWZpbmUtc2V4cC1wYXJzZXIgTEVGVEFSUk9XIGJv ZHkKICAgKGFuZCAob3IgIjwtLSIgIjwtIiAiPCIpIFNwYWNpbmcpKSA7IE5PVEU6IDwtLSBh bmQgPCBhcmUgZXh0ZW5zaW9ucworKGRlZmluZS1zZXhwLXBhcnNlciBOT1RJTiBub25lCisg IChhbmQgIl4iKSkKIChkZWZpbmUtc2V4cC1wYXJzZXIgU0xBU0ggbm9uZQogICAoYW5kICIv IiBTcGFjaW5nKSkKIChkZWZpbmUtc2V4cC1wYXJzZXIgQU5EIGFsbApAQCAtMjc1LDYgKzI4 NCw3IEBAIEVuZE9mRmlsZSA8ICEuCiAgICAgICAoJ0lkZW50aWZpZXIgKElkZW50aWZpZXIt PmRlZm4gdmFsdWUgZm9yLXN5bnRheCkpCiAgICAgICAoJ0V4cHJlc3Npb24gKEV4cHJlc3Np b24tPmRlZm4gdmFsdWUgZm9yLXN5bnRheCkpCiAgICAgICAoJ0xpdGVyYWwgICAgKExpdGVy YWwtPmRlZm4gdmFsdWUgZm9yLXN5bnRheCkpCisgICAgICAoJ05vdEluQ2xhc3MgKE5vdElu Q2xhc3MtPmRlZm4gdmFsdWUgZm9yLXN5bnRheCkpCiAgICAgICAoJ0NsYXNzICAgICAgKENs YXNzLT5kZWZuIHZhbHVlIGZvci1zeW50YXgpKSkpKQogCiA7OyAoSWRlbnRpZmllciAiaGVs bG8iKQpAQCAtMjg3LDEzICsyOTcsMzQgQEAgRW5kT2ZGaWxlIDwgIS4KIChkZWZpbmUgKExp dGVyYWwtPmRlZm4gbHN0IGZvci1zeW50YXgpCiAgIChhcHBseSBzdHJpbmcgKG1hcCAobGFt YmRhICh4KSAoQ2hhci0+ZGVmbiB4IGZvci1zeW50YXgpKSAoY2RyIGxzdCkpKSkKIAotOzsg VE9ETzogZW1wdHkgQ2xhc3MgY2FuIGhhcHBlbjogYFtdYCwgYnV0IHdoYXQgZG9lcyBpdCBy ZXByZXNlbnQ/Cis7OyAoTm90SW5DbGFzcyAuLi4pCis7OyAgYC0+IChhbmQgLi4uKQorKGRl ZmluZSAoTm90SW5DbGFzcy0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKKyAgI2AoYW5kICMsQCht YXAgKGxhbWJkYSAoeCkgKE5vdEluUmFuZ2UtPmRlZm4geCBmb3Itc3ludGF4KSkKKyAgICAg ICAgICAgICAgICAgKGNkciBsc3QpKSkpCisKIDs7IChDbGFzcyAuLi4pCiA7OyAgYC0+IChv ciAuLi4pCiAoZGVmaW5lIChDbGFzcy0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKICAgI2Aob3Ig IyxAKG1hcCAobGFtYmRhICh4KSAoUmFuZ2UtPmRlZm4geCBmb3Itc3ludGF4KSkKICAgICAg ICAgICAgICAgICAoY2RyIGxzdCkpKSkKIAorOzsgRm9yIG9uZSBjaGFyYWN0ZXI6Cis7OyAo Tm90SW5SYW5nZSAoQ2hhciAiYSIpKQorOzsgIGAtPiAobm90LWluLXJhbmdlICNcYSAjXGEp Cis7OyBPciBmb3IgYSByYW5nZToKKzs7IChOb3RJblJhbmdlIChDaGFyICJhIikgKENoYXIg ImIiKSkKKzs7ICBgLT4gKG5vdC1pbi1yYW5nZSAjXGEgI1xiKQorKGRlZmluZSAoTm90SW5S YW5nZS0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKKyAgKGNvbmQKKyAgICAoKD0gMiAobGVuZ3Ro IGxzdCkpCisgICAgIChsZXQgKChjaCAoQ2hhci0+ZGVmbiAoc2Vjb25kIGxzdCkgZm9yLXN5 bnRheCkpKQorICAgICAgICNgKG5vdC1pbi1yYW5nZSAjLGNoICMsY2gpKSkKKyAgICAoKD0g MyAobGVuZ3RoIGxzdCkpCisgICAgICNgKG5vdC1pbi1yYW5nZQorICAgICAgICAgIywoQ2hh ci0+ZGVmbiAoc2Vjb25kIGxzdCkgZm9yLXN5bnRheCkKKyAgICAgICAgICMsKENoYXItPmRl Zm4gKHRoaXJkIGxzdCkgZm9yLXN5bnRheCkpKSkpCisKIDs7IEZvciBvbmUgY2hhcmFjdGVy OgogOzsgKFJhbmdlIChDaGFyICJhIikpCiA7OyAgYC0+ICJhIgpkaWZmIC0tZ2l0IGEvdGVz dC1zdWl0ZS90ZXN0cy9wZWcudGVzdCBiL3Rlc3Qtc3VpdGUvdGVzdHMvcGVnLnRlc3QKaW5k ZXggNTU2MTQ1ZTcyLi45NjVlMWMxMmYgMTAwNjQ0Ci0tLSBhL3Rlc3Qtc3VpdGUvdGVzdHMv cGVnLnRlc3QKKysrIGIvdGVzdC1zdWl0ZS90ZXN0cy9wZWcudGVzdApAQCAtMzgsNiArMzgs NyBAQAogICAgIChJZGVudGlmaWVyIElkZW50aWZpZXIpCiAgICAgKExpdGVyYWwgTGl0ZXJh bCkKICAgICAoQ2xhc3MgQ2xhc3MpCisgICAgKE5vdEluQ2xhc3MgTm90SW5DbGFzcykKICAg ICAoUmFuZ2UgUmFuZ2UpCiAgICAgKENoYXIgQ2hhcikKICAgICAoTEVGVEFSUk9XIExFRlRB UlJPVykKQEAgLTg1LDcgKzg2LDcgQEAKIEVuZCA8LS0gJyopJwogQyA8LSBCZWdpbiBOKiBF bmQKIE4gPC0gQyAvICghQmVnaW4gIUVuZCBaKQotWiA8LSAuIikKK1ogPC0gW15YLVpdIikg OzsgRm9yYmlkIHNvbWUgY2hhcmFjdGVycyB0byB0ZXN0IG5vdC1pbi1yYW5nZQogCiA7OyBB IHNob3J0IC9ldGMvcGFzc3dkIGZpbGUuCiAoZGVmaW5lICpldGMtcGFzc3dkKgpAQCAtMTI1 LDYgKzEyNiw5IEBAIFNMQVNIIDwgJy8nIikKICAgICAobWF0Y2gtcGF0dGVybiBDICIoKmJs YWgqKSIpCiAgICAgKG1ha2UtcHJlYyAwIDggIigqYmxhaCopIgogCSAgICAgICAnKChCZWdp biAiKCoiKSAiYmxhaCIgKEVuZCAiKikiKSkpKSkKKyAgKHBhc3MtaWYKKyAgICJzaW1wbGUg Y29tbWVudCB3aXRoIGZvcmJpZGRlbiBjaGFyIgorICAgKG5vdCAobWF0Y2gtcGF0dGVybiBD ICIoKmJsWWgqKSIpKSkKICAgKHBhc3MtaWYKICAgICJzaW1wbGUgY29tbWVudCBwYWRkZWQi CiAgICAoZXF1YWw/Ci0tIAoyLjQ2LjAKCg== --------------3N0zblOVoqBRwSKdoRkb0HaK-- From debbugs-submit-bounces@debbugs.gnu.org Sun Oct 20 06:11:25 2024 Received: (at 73188) by debbugs.gnu.org; 20 Oct 2024 10:11:25 +0000 Received: from localhost ([127.0.0.1]:45945 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1t2SuC-0006tj-Hd for submit@debbugs.gnu.org; Sun, 20 Oct 2024 06:11:25 -0400 Received: from eggs.gnu.org ([209.51.188.92]:47496) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1t2SuA-0006tT-CL for 73188@debbugs.gnu.org; Sun, 20 Oct 2024 06:11:23 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1t2Ste-0002RN-Ub; Sun, 20 Oct 2024 06:10:50 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnu.org; s=fencepost-gnu-org; h=MIME-Version:Date:References:In-Reply-To:Subject:To: From; bh=IFSSgCxko5iXzXNEd4+hEGd+RHSgiQbzUXWIi51T0pU=; b=knRyVNAV3mT0v0sd88jH WJkl6FYAQLWyytfVCAlc7g7/6AITObJ2PZH2fq54Gx4ZOCByKuudvhwVv1lr+JzpE43XtZ+NrxVOL +Qc6k52n189Kd5QktpUtWHvwrxweTXOjNs+1jgiz/sxDPJcbblXiCepY0hKpcwnAzOlqWI6b7jqBE 64rg0ljSM2t7oKfst8vqf8H1g4mWcoRYOLu91iie8JkGnX7mXFeKFm1Vx5Tow43cPrvjqGyj6s0Sn RyGjfMtNWSA+aovgreYD1+QP+93GVDGNaJe9IFgBIBSsEhs25jjk5iZKX+4Sur96LZsk+SAwBYmbf LbSjiffku7GVhQ==; From: =?utf-8?Q?Ludovic_Court=C3=A8s?= To: Ekaitz Zarraga Subject: Re: bug#73188: PEG parser does not support full PEG grammar In-Reply-To: (Ekaitz Zarraga's message of "Mon, 14 Oct 2024 16:00:02 +0200") References: <78a81bc5-cd0d-0506-185b-c733c66e96ae@elenq.tech> <20240912205751.23724-1-ekaitz@elenq.tech> <87cyk3rbkc.fsf_-_@gnu.org> <168e01eb-ac58-4d39-a960-46624e65edde@elenq.tech> <875xpu3nl7.fsf@gnu.org> Date: Sun, 20 Oct 2024 12:10:47 +0200 Message-ID: <87ldyjm6e0.fsf@gnu.org> User-Agent: Gnus/5.13 (Gnus v5.13) MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 73188 Cc: 73188@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) Egun on Ekaitz, Ekaitz Zarraga skribis: > - What it is true is if people were using `peg-as-peg` for their > things, which isn't even exported by the module, their code would > have problems. But we can't predict that. Since =E2=80=98peg-as-peg=E2=80=99 has always been private, that=E2=80=99s = fine. > From 81944c2037e0d6d8c972def2ceb1aa4c51a61431 Mon Sep 17 00:00:00 2001 > From: Ekaitz Zarraga > Date: Wed, 11 Sep 2024 21:19:26 +0200 > Subject: [PATCH v3 1/2] PEG: Add full support for PEG + some extensions > > This commit adds support for PEG as described in: > > > > It adds support for the missing features (comments, underscores in > identifiers and escaping) while keeping the extensions (dashes in > identifiers, < and <--). > > The naming system tries to be as close as possible to the one proposed > in the paper. > > * module/ice-9/peg/string-peg.scm: Rewrite PEG parser. > * test-suite/tests/peg.test: Fix import [...] > +(define (Primary->defn lst for-syntax) > + (let ((value (second lst))) > + (case (car value) > + ('DOT #'peg-any) > + ('Identifier (Identifier->defn value for-syntax)) > + ('Expression (Expression->defn value for-syntax)) > + ('Literal (Literal->defn value for-syntax)) > + ('Class (Class->defn value for-syntax))))) I get these compiler warnings: --8<---------------cut here---------------start------------->8--- ice-9/peg/string-peg.scm:258:7: warning: duplicate datum quote in clause ((= quote NOT) (quasisyntax (not-followed-by (unsyntax (Suffix->defn (third lst= ) for-syntax))))) of case expression (case (car suffix) ((quote AND) (quasi= syntax (followed-by (unsyntax (Suffix->defn (third lst) for-syntax))))) ((q= uote NOT) (quasisyntax (not-followed-by (unsyntax (Suffix->defn (third lst)= for-syntax))))) (else (Suffix->defn suffix for-syntax))) ice-9/peg/string-peg.scm:277:9: warning: duplicate datum quote in clause ((= quote STAR) (quasisyntax (* (unsyntax out)))) of case expression (case (caa= r extra) ((quote QUESTION) (quasisyntax (? (unsyntax out)))) ((quote STAR) = (quasisyntax (* (unsyntax out)))) ((quote PLUS) (quasisyntax (+ (unsyntax o= ut))))) ice-9/peg/string-peg.scm:278:9: warning: duplicate datum quote in clause ((= quote PLUS) (quasisyntax (+ (unsyntax out)))) of case expression (case (caa= r extra) ((quote QUESTION) (quasisyntax (? (unsyntax out)))) ((quote STAR) = (quasisyntax (* (unsyntax out)))) ((quote PLUS) (quasisyntax (+ (unsyntax o= ut))))) ice-9/peg/string-peg.scm:284:7: warning: duplicate datum quote in clause ((= quote Identifier) (Identifier->defn value for-syntax)) of case expression (= case (car value) ((quote DOT) (syntax peg-any)) ((quote Identifier) (Identi= fier->defn value for-syntax)) ((quote Expression) (Expression->defn value f= or-syntax)) ((quote Literal) (Literal->defn value for-syntax)) ((quote NotI= nClass) (NotInClass->defn value for-syntax)) ((quote Class) (Class->defn va= lue for-syntax))) ice-9/peg/string-peg.scm:285:7: warning: duplicate datum quote in clause ((= quote Expression) (Expression->defn value for-syntax)) of case expression (= case (car value) ((quote DOT) (syntax peg-any)) ((quote Identifier) (Identi= fier->defn value for-syntax)) ((quote Expression) (Expression->defn value f= or-syntax)) ((quote Literal) (Literal->defn value for-syntax)) ((quote NotI= nClass) (NotInClass->defn value for-syntax)) ((quote Class) (Class->defn va= lue for-syntax))) ice-9/peg/string-peg.scm:286:7: warning: duplicate datum quote in clause ((= quote Literal) (Literal->defn value for-syntax)) of case expression (case (= car value) ((quote DOT) (syntax peg-any)) ((quote Identifier) (Identifier->= defn value for-syntax)) ((quote Expression) (Expression->defn value for-syn= tax)) ((quote Literal) (Literal->defn value for-syntax)) ((quote NotInClass= ) (NotInClass->defn value for-syntax)) ((quote Class) (Class->defn value fo= r-syntax))) ice-9/peg/string-peg.scm:287:7: warning: duplicate datum quote in clause ((= quote NotInClass) (NotInClass->defn value for-syntax)) of case expression (= case (car value) ((quote DOT) (syntax peg-any)) ((quote Identifier) (Identi= fier->defn value for-syntax)) ((quote Expression) (Expression->defn value f= or-syntax)) ((quote Literal) (Literal->defn value for-syntax)) ((quote NotI= nClass) (NotInClass->defn value for-syntax)) ((quote Class) (Class->defn va= lue for-syntax))) ice-9/peg/string-peg.scm:288:7: warning: duplicate datum quote in clause ((= quote Class) (Class->defn value for-syntax)) of case expression (case (car = value) ((quote DOT) (syntax peg-any)) ((quote Identifier) (Identifier->defn= value for-syntax)) ((quote Expression) (Expression->defn value for-syntax)= ) ((quote Literal) (Literal->defn value for-syntax)) ((quote NotInClass) (N= otInClass->defn value for-syntax)) ((quote Class) (Class->defn value for-sy= ntax))) --8<---------------cut here---------------end--------------->8--- And indeed, the correct syntax is: (case value (DOT =E2=80=A6) (Identifier =E2=80=A6) =E2=80=A6) or: (match value ('DOT =E2=80=A6) ('Identifier =E2=80=A6) =E2=80=A6) The former returns *unspecified* when passed a value not matched by any clause, whereas the latter throws an error. So I would recommend =E2=80=98match=E2=80=99. At any rate, that makes me wonder whether this code path is tested at all. As written, =E2=80=98Primary->defn=E2=80=99 would always return *unsp= ecified*. Is there a test we could add? > +(define (Range->defn lst for-syntax) > (cond > - ((list? el) > - (cond > - ((eq? (car el) 'peg-literal) > - (peg-literal->defn el for-syntax)) > - ((eq? (car el) 'peg-charclass) > - (peg-charclass->defn el for-syntax)) > - ((eq? (car el) 'peg-nonterminal) > - (datum->syntax for-syntax (string->symbol (cadr el)))))) > - ((string? el) > + ((=3D 2 (length lst)) > + (second (second lst))) > + ((=3D 3 (length lst)) > + #`(range > + #,(Char->defn (second lst) for-syntax) > + #,(Char->defn (third lst) for-syntax))))) Keep in mind that =E2=80=98length=E2=80=99 is O(N), and that car/first, sec= ond/cadr are frowned upon. I would write it as: (match lst ((x y) y) ((x y z) #`(range =E2=80=A6))) (Ideally with identifiers more meaningful than x, y, and z. :-)) > ;; Transforms the nonterminals defined in the PEG parser written as a PE= G to the nonterminals defined in the PEG parser written with S-expressions. > (define (grammar-transform x) > @@ -69,7 +77,7 @@ > (peg:tree (match-pattern (@@ (ice-9 peg) peg-grammar) (@@ (ice-9 peg= ) peg-as-peg))) > (tree-map > grammar-transform > - (peg:tree (match-pattern grammar (@@ (ice-9 peg) peg-as-peg))))))) > + (peg:tree (match-pattern (@@ (ice-9 peg) peg-grammar) (@@ (ice-9 pe= g) peg-as-peg))))))) What happened to the =E2=80=98grammar=E2=80=99 binding? I can=E2=80=99t se= e where it was coming from. > From 64a17be08581465d11185b4a0ca636354d2f944c Mon Sep 17 00:00:00 2001 > From: Ekaitz Zarraga > Date: Fri, 11 Oct 2024 14:24:30 +0200 > Subject: [PATCH v3 2/2] PEG: Add support for `not-in-range` and [^...] > > Modern PEG supports inversed class like `[^a-z]` that would get any > character not in the `a-z` range. This commit adds support for that and > also for a new `not-in-range` PEG pattern for scheme. > > * module/ice-9/peg/codegen.scm (cg-not-in-range): New function. > * module/ice-9/peg/string-peg.scm: Add support for `[^...]` > * test-suite/tests/peg.test: Test it. > * doc/ref/api-peg.texi: Document accordingly. This one LGTM. In addition to the issues mentioned above, could you add an entry in the =E2=80=98NEWS=E2=80=99 file, probably under a new =E2=80=9CNew interfaces a= nd functionality=E2=80=9D heading? Thanks, Ludo=E2=80=99. From debbugs-submit-bounces@debbugs.gnu.org Sun Oct 20 16:19:32 2024 Received: (at 73188) by debbugs.gnu.org; 20 Oct 2024 20:19:32 +0000 Received: from localhost ([127.0.0.1]:48983 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1t2cOf-0003Al-SJ for submit@debbugs.gnu.org; Sun, 20 Oct 2024 16:19:32 -0400 Received: from dane.soverin.net ([185.233.34.31]:55471) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1t2cOb-0003AR-O9 for 73188@debbugs.gnu.org; Sun, 20 Oct 2024 16:19:28 -0400 Received: from smtp.soverin.net (c04smtp-lb01.int.sover.in [10.10.4.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by dane.soverin.net (Postfix) with ESMTPS id 4XWqXF6XWVz2xTl; Sun, 20 Oct 2024 20:18:53 +0000 (UTC) Received: from smtp.soverin.net (smtp.soverin.net [10.10.4.100]) by soverin.net (Postfix) with ESMTPSA id 4XWqXF1vJ3z9j; Sun, 20 Oct 2024 20:18:53 +0000 (UTC) Authentication-Results: smtp.soverin.net; dkim=pass (2048-bit key; unprotected) header.d=elenq.tech header.i=@elenq.tech header.a=rsa-sha256 header.s=soverin1 header.b=vQpYHy0V; dkim-atps=neutral DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=elenq.tech; s=soverin1; t=1729455533; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: in-reply-to:in-reply-to:references:references:autocrypt:autocrypt; bh=PU520EfDAOVmKNyNpkzuxRpjIhcnbaGEa2uYL+WvfgM=; b=vQpYHy0VEL8vseRK4UJLeaEZKUav3M1ENainVx5fp7tOnZM1gLV0wpwYKpBI3kRQHWsu9A FlURK2zLqm2Yryees+FCNibe+UHJy0MYHABs6ToO10ww+0gPeBv8xOZkSRCHLezF44BClm p4YWkrBAJem4sol8Fp2kqnrlbGQjNspgQ6lrjEEXF74eQIU+tKkrNOnaCTdp7lIP77COxn rQl1XCWGWFkaQdJVgtEdIQct8/+ZKr/AmSno9eiKGE88oTAyJGse5Q055O7HHW2nNnBPz5 PdqmpQmfabuvBbm5ej/KgBrd/cCCgCbHYmPXhKn2oiHIqCGu9Nx89TuQsloFpg== Content-Type: multipart/mixed; boundary="------------QKBL2uiBJnbd9YBTHqXA1fU1" Message-ID: <57321eb4-962c-4994-b48a-518943b58941@elenq.tech> Date: Sun, 20 Oct 2024 22:18:52 +0200 MIME-Version: 1.0 Subject: Re: bug#73188: PEG parser does not support full PEG grammar To: =?UTF-8?Q?Ludovic_Court=C3=A8s?= References: <78a81bc5-cd0d-0506-185b-c733c66e96ae@elenq.tech> <20240912205751.23724-1-ekaitz@elenq.tech> <87cyk3rbkc.fsf_-_@gnu.org> <168e01eb-ac58-4d39-a960-46624e65edde@elenq.tech> <875xpu3nl7.fsf@gnu.org> <87ldyjm6e0.fsf@gnu.org> Content-Language: en-US, es-ES, eu From: Ekaitz Zarraga Autocrypt: addr=ekaitz@elenq.tech; keydata= xsFNBGViSyIBEADY3g71uW/0CVaVm5/ObqTicQXXJRuh1uafIFiUUZoAp1V3V89b3LZ/m0cL 8YNHxTxsx8sKIMYTGlOvARAMiSpDvkmpf5pLn5T7+VvK90FOv/Pkp1tNNT+tvd0m/7C58+39 s7tN+XppbjVRtFuSXY0aFe8rpivZsKxv+tPUHUnQQszXvwgx0GQl8AX99IE+j75NJmBHFVg2 0geKa7QVymu669ix2+zU8vGoOKf5nIS0qG1m/vrtwR3ZuuyWX9/E/uP95ahX5ETWtjhTDbEm MEaRperwbczBewkdERJ34vRrverqKQA1xHXoPsx4NkLMocORFSSCJsveXcgWlU+pUIOYcKUA ARJjHhoWoUH4LZt5EOb7U17AaYMmATUXPCqq8G3jEXq6i0O1J1obCJGIRG02R9GiGp4zrVuv 2hmyoAmed4xYZAtf9WjcbwiunDkMGIxscdSlfEH/9dt7PGdEvkZ0dNSCTbp4ctMI4jAfobAL LReMSGx1CgPi01J61a/n/SgR66AiRJZCyC1u2V7AK1rBOAYzOU4UoePz+yF1I7crjZWAQVo6 DlmmXW+29l/lh2oK5jOuNEcvI6qi+tPCYxpDhUhZeYgqFU+/xgGlMj/XGvwuIFlpVg9ovFMg 6mxskOCVP9xNEp/qHiHqByYu5NRcITo/z/3BUimdXTT4KSq2cQARAQABzSJFa2FpdHogWmFy cmFnYSA8ZWthaXR6QGVsZW5xLnRlY2g+wsGOBBMBCAA4FiEEg/pnRVjAUpRlfkwZt5lM+Jly CyYFAmViSyICGwMFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQt5lM+JlyCybjZxAAy+YW 3Q22xKoMWJYw03qGCy87WPK+xGWDpKD6TJ77+/IEbldObyQRrKYTTGjQSy6WgaJ0txJMIqeK JyuWuR3bq+Vkh86Byntl25jknOJ+jY1zwPs6HnWFr+hS48FcQh/0D26h57Cqc+6nbKhJcva8 JsInbHTbWPz7wye+xhqY1LfdgVTbCyADESXdmBY30/vP4LzqW81atwYF6X7dN7ko/JvyPPdv VlcspmbP6zNihoApBHdMfJwYscyAsu6tTyL4hMG3zpraeU+S857vZN39gFagRng+uyZG7rfB dHHAFzT1LKOZ4dahavOfA0gS1RZTgtAGsvhUEBn9vKxlB4efZuKhwMtgQEskRFD6JIF1DYCj pLgn5x/y3oI6rn35R46VDhLfohcUWpvzplu6LBft8ZNr+UgoVYc6qBezyDlxk0FmhGI7DEoh gfUxljTALXjSdUGEw2mvp/Mcrz+ffemWpG4+Zq0UXR8sZaHpv+PqmFLFFSQCOCRTYbMKzZBn y03wym3y0tGtunDGm5pR7NEPqUO9QbZdKyTy4ftRkSfTpiPCF8+KKYDT8HimSrusmtTfR4R1 nBJ4lNBYgTdOyJYFbHdF0Jxo9r0t+K2e+6hX6bK79o6aC+/LtzkoYgjCWvAEopO0ras/XQYM S7/bCzeDIhXX5RqmMIp5XN+oBP2roZDOwU0EZWJLIgEQAMIgPDpJY9aOhFiFICx58XMM28An yUPdN39t0A8VkUbsvKXH6eNqUZj/Q3yNcZrknAT1vinv9FN/4uCUnsaqEKp+mRAYgzmNfeJk SWuMzmA04fcISIBz3sJUR0w/59tWi8QxlNn7IR6McAA3lHDXC+KYh9ZfhaOARfan1M6Ppy6g YltUQGSSPXU807inmQZh8GFTi8iUza7vGuBEnaNRGhmhR+blMwHSqVWN4gD81e8dSAEi3zNR sLoBXneHUqTcJMHvsT5cOk7cGMoVAWIffA2EKWfrgda57Qw+w+0OPqWEfKoXwnyt35Tl+Lxl 7MAaAG9R5760yhgkf3LmnBNP3m6StZ8Fv09Gdn5cGSbVnoofHDkg4PQDTD6aGz9af3SnGVg9 nb1Zm1XbqtnYwG9JvQhcjgWAHwrPLkHAcvKtfYWNe4wiirMjXMXxADY08g33SEchPJR2r4pg wttJS4kHUJ2IQUmSH/43RO5PkftWsCucYGeaG1aPr+GAkeKIS1M3OZGuqhd800mltpiH73eL XrUPF8fgngC+SGMrHXLfzuhaRxPNYUbsdF+wRkvjRSO4tCmSVpgfPsHu5emoZgix1iiTO7GF do7L6n1Ay3oF4Witoxc0Gcbu7ltYlZHGmDnsVTVALartsJV2muSXpWcjQiXyC0gUkIkUD/3P jtgVxK8xABEBAAHCwXYEGAEIACAWIQSD+mdFWMBSlGV+TBm3mUz4mXILJgUCZWJLIgIbDAAK CRC3mUz4mXILJrIaD/9CXGckwRCojuRzP0r6+8/RvNDc03CSe2W17WrSaoYgiRb+h5asI/AL yqw+QRgwXZpt0i9hNiDCe/baD62mufIyjKFjHoAWSYJuZ5VK3vWnro6GaxWULYt1+c4c4Lz2 d1nSK6j8F3CxYo7BFk6afOusjYfh+0HywThcYY+x+K5Z+4SdJejDLiL5AzJn2W5Gt/ViK5nI wl7uRQpayMc9zmI8ytUT2NJxovq1/fT9nB8VPwlbJTE9zvIqfqHh9o9Apx5o8yTaSCyGUyu9 8h/klqxFy4HAPJJu/3JkiMaCI45ZdCqRR1LIwhtmW2lb73r0rP/0S1cKi+ehA4oQvwiUw7zh XXw7mqzSAJ0SWT92Vy2G8Z8qqgwxwfQcdFZAyJAL1rgEPQljNT91Vgbc6DCUka2XW5BqyhEB eS0n1gK0hYXbM9FKegRsZxlmRAXa4KGXCwr4BNK6k+zkKPitezjbtcLgcKSHa8/HyHNkW7xH R+MN16x2elQPmQ2d0Ien1HgsK98+3prlUGwZIVCqa1ddSoW0llU3JzGsKrMAiYbWg/rOXFil RJbuhjflaLBVmfI8VlRQRocP+WEH0lsUWrtjVaGcBj1/YnIoT+zT6fPSXwPsrBvAWEjfl8HH e1F4cYb+ugPDwUTd1s2Uj2tF0/fhCHPy9sXyx/EIL3gqyBw9M2Rz9A== In-Reply-To: <87ldyjm6e0.fsf@gnu.org> X-Spampanel-Class: ham X-Spam-Score: -0.7 (/) X-Debbugs-Envelope-To: 73188 Cc: 73188@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.7 (-) This is a multi-part message in MIME format. --------------QKBL2uiBJnbd9YBTHqXA1fU1 Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Hi Ludovic, Thanks for the review On 2024-10-20 12:10, Ludovic Courtès wrote: >> +(define (Primary->defn lst for-syntax) >> + (let ((value (second lst))) >> + (case (car value) >> + ('DOT #'peg-any) >> + ('Identifier (Identifier->defn value for-syntax)) >> + ('Expression (Expression->defn value for-syntax)) >> + ('Literal (Literal->defn value for-syntax)) >> + ('Class (Class->defn value for-syntax))))) > > I get these compiler warnings: > > --8<---------------cut here---------------start------------->8--- > ice-9/peg/string-peg.scm:258:7: warning: duplicate datum quote in clause ((quote NOT) (quasisyntax (not-followed-by (unsyntax (Suffix->defn (third lst) for-syntax))))) of case expression (case (car suffix) ((quote AND) (quasisyntax (followed-by (unsyntax (Suffix->defn (third lst) for-syntax))))) ((quote NOT) (quasisyntax (not-followed-by (unsyntax (Suffix->defn (third lst) for-syntax))))) (else (Suffix->defn suffix for-syntax))) > ice-9/peg/string-peg.scm:277:9: warning: duplicate datum quote in clause ((quote STAR) (quasisyntax (* (unsyntax out)))) of case expression (case (caar extra) ((quote QUESTION) (quasisyntax (? (unsyntax out)))) ((quote STAR) (quasisyntax (* (unsyntax out)))) ((quote PLUS) (quasisyntax (+ (unsyntax out))))) > ice-9/peg/string-peg.scm:278:9: warning: duplicate datum quote in clause ((quote PLUS) (quasisyntax (+ (unsyntax out)))) of case expression (case (caar extra) ((quote QUESTION) (quasisyntax (? (unsyntax out)))) ((quote STAR) (quasisyntax (* (unsyntax out)))) ((quote PLUS) (quasisyntax (+ (unsyntax out))))) > ice-9/peg/string-peg.scm:284:7: warning: duplicate datum quote in clause ((quote Identifier) (Identifier->defn value for-syntax)) of case expression (case (car value) ((quote DOT) (syntax peg-any)) ((quote Identifier) (Identifier->defn value for-syntax)) ((quote Expression) (Expression->defn value for-syntax)) ((quote Literal) (Literal->defn value for-syntax)) ((quote NotInClass) (NotInClass->defn value for-syntax)) ((quote Class) (Class->defn value for-syntax))) > ice-9/peg/string-peg.scm:285:7: warning: duplicate datum quote in clause ((quote Expression) (Expression->defn value for-syntax)) of case expression (case (car value) ((quote DOT) (syntax peg-any)) ((quote Identifier) (Identifier->defn value for-syntax)) ((quote Expression) (Expression->defn value for-syntax)) ((quote Literal) (Literal->defn value for-syntax)) ((quote NotInClass) (NotInClass->defn value for-syntax)) ((quote Class) (Class->defn value for-syntax))) > ice-9/peg/string-peg.scm:286:7: warning: duplicate datum quote in clause ((quote Literal) (Literal->defn value for-syntax)) of case expression (case (car value) ((quote DOT) (syntax peg-any)) ((quote Identifier) (Identifier->defn value for-syntax)) ((quote Expression) (Expression->defn value for-syntax)) ((quote Literal) (Literal->defn value for-syntax)) ((quote NotInClass) (NotInClass->defn value for-syntax)) ((quote Class) (Class->defn value for-syntax))) > ice-9/peg/string-peg.scm:287:7: warning: duplicate datum quote in clause ((quote NotInClass) (NotInClass->defn value for-syntax)) of case expression (case (car value) ((quote DOT) (syntax peg-any)) ((quote Identifier) (Identifier->defn value for-syntax)) ((quote Expression) (Expression->defn value for-syntax)) ((quote Literal) (Literal->defn value for-syntax)) ((quote NotInClass) (NotInClass->defn value for-syntax)) ((quote Class) (Class->defn value for-syntax))) > ice-9/peg/string-peg.scm:288:7: warning: duplicate datum quote in clause ((quote Class) (Class->defn value for-syntax)) of case expression (case (car value) ((quote DOT) (syntax peg-any)) ((quote Identifier) (Identifier->defn value for-syntax)) ((quote Expression) (Expression->defn value for-syntax)) ((quote Literal) (Literal->defn value for-syntax)) ((quote NotInClass) (NotInClass->defn value for-syntax)) ((quote Class) (Class->defn value for-syntax))) > --8<---------------cut here---------------end--------------->8--- > > And indeed, the correct syntax is: > > (case value (DOT …) (Identifier …) …) > > or: > > (match value ('DOT …) ('Identifier …) …) > > The former returns *unspecified* when passed a value not matched by any > clause, whereas the latter throws an error. > > So I would recommend ‘match’. I'm always in doubt with this but the thing worked. I always check in the internet how to do the case, and I always get the warning... my bad! > At any rate, that makes me wonder whether this code path is tested at > all. As written, ‘Primary->defn’ would always return *unspecified*. > Is there a test we could add? I made some tests and it works, maybe unexpectedly: scheme@(guile-user)> (define a 'b) scheme@(guile-user)> (case a ('c 3)('b 1)('d 2)) ;;; :12:15: warning: duplicate datum quote in clause ((quote b) 1) of case expression (case a ((quote c) 3) ((quote b) 1) ((quote d) 2)) ;;; :12:21: warning: duplicate datum quote in clause ((quote d) 2) of case expression (case a ((quote c) 3) ((quote b) 1) ((quote d) 2)) $8 = 1 While your proposal doesn't: scheme@(guile-user)> (case a (c 3)(b 1)(d 2)) While compiling expression: Syntax error: unknown file:14:8: case: invalid clause in subform (c 3) of (case a (c 3) (b 1) (d 2)) I tested further and this is what it should be: scheme@(guile-user)> (case a ((b) 1)((d) 2)) $1 = 1 I used match instead as you proposed and made it all work with no warnings and better error reporting. >> +(define (Range->defn lst for-syntax) >> (cond >> - ((list? el) >> - (cond >> - ((eq? (car el) 'peg-literal) >> - (peg-literal->defn el for-syntax)) >> - ((eq? (car el) 'peg-charclass) >> - (peg-charclass->defn el for-syntax)) >> - ((eq? (car el) 'peg-nonterminal) >> - (datum->syntax for-syntax (string->symbol (cadr el)))))) >> - ((string? el) >> + ((= 2 (length lst)) >> + (second (second lst))) >> + ((= 3 (length lst)) >> + #`(range >> + #,(Char->defn (second lst) for-syntax) >> + #,(Char->defn (third lst) for-syntax))))) > > Keep in mind that ‘length’ is O(N), and that car/first, second/cadr are > frowned upon. I would write it as: > > (match lst > ((x y) y) > ((x y z) #`(range …))) Yeah, I was very bad at `match` when I wrote this thing :( But! Now I spent some hours with it and rewrote the thing for `match`! > (Ideally with identifiers more meaningful than x, y, and z. :-)) > >> ;; Transforms the nonterminals defined in the PEG parser written as a PEG to the nonterminals defined in the PEG parser written with S-expressions. >> (define (grammar-transform x) >> @@ -69,7 +77,7 @@ >> (peg:tree (match-pattern (@@ (ice-9 peg) peg-grammar) (@@ (ice-9 peg) peg-as-peg))) >> (tree-map >> grammar-transform >> - (peg:tree (match-pattern grammar (@@ (ice-9 peg) peg-as-peg))))))) >> + (peg:tree (match-pattern (@@ (ice-9 peg) peg-grammar) (@@ (ice-9 peg) peg-as-peg))))))) > > What happened to the ‘grammar’ binding? I can’t see where it was coming > from. This is a very good catch! I "fixed" a missing identifier by this, but it happened to be skipping a really important check: Is our PEG written as PEG understood like our PEG definition in sexps? The `Grammar` is coming from the processing of `peg-as-peg` as a peg-string. This is what I was missing. This was hiding some errors that I fixed, and now I'm pretty confident of the thing. Wow! This was a very good one! Thanks for pointing it out. >> From 64a17be08581465d11185b4a0ca636354d2f944c Mon Sep 17 00:00:00 2001 >> From: Ekaitz Zarraga >> Date: Fri, 11 Oct 2024 14:24:30 +0200 >> Subject: [PATCH v3 2/2] PEG: Add support for `not-in-range` and [^...] >> >> Modern PEG supports inversed class like `[^a-z]` that would get any >> character not in the `a-z` range. This commit adds support for that and >> also for a new `not-in-range` PEG pattern for scheme. >> >> * module/ice-9/peg/codegen.scm (cg-not-in-range): New function. >> * module/ice-9/peg/string-peg.scm: Add support for `[^...]` >> * test-suite/tests/peg.test: Test it. >> * doc/ref/api-peg.texi: Document accordingly. > > This one LGTM. > > In addition to the issues mentioned above, could you add an entry in the > ‘NEWS’ file, probably under a new “New interfaces and functionality” > heading? Yes! Added it in both commits: In the first commit I added that PEG was improved, and in the second that `not-in-range` was added. > Thanks, > Ludo’. Attached new version of both patches. Thanks for the help, the kind of things you point out are the ones that I wanted help with! Thanks! Now I'm a better matcher. This helps me improve, Ekaitz --------------QKBL2uiBJnbd9YBTHqXA1fU1 Content-Type: text/x-patch; charset=UTF-8; name="v4-0002-PEG-Add-support-for-not-in-range-and.patch" Content-Disposition: attachment; filename="v4-0002-PEG-Add-support-for-not-in-range-and.patch" Content-Transfer-Encoding: base64 RnJvbSA3OTQxNTg5OTQxZmU3YTBmYjZmNzFiODY4MWNjYjFkOTc2OTQ2OTEyIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBFa2FpdHogWmFycmFnYSA8ZWthaXR6QGVsZW5xLnRl Y2g+CkRhdGU6IEZyaSwgMTEgT2N0IDIwMjQgMTQ6MjQ6MzAgKzAyMDAKU3ViamVjdDogW1BB VENIIHY0IDIvMl0gUEVHOiBBZGQgc3VwcG9ydCBmb3IgYG5vdC1pbi1yYW5nZWAgYW5kIFte Li4uXQoKTW9kZXJuIFBFRyBzdXBwb3J0cyBpbnZlcnNlZCBjbGFzcyBsaWtlIGBbXmEtel1g IHRoYXQgd291bGQgZ2V0IGFueQpjaGFyYWN0ZXIgbm90IGluIHRoZSBgYS16YCByYW5nZS4g VGhpcyBjb21taXQgYWRkcyBzdXBwb3J0IGZvciB0aGF0IGFuZAphbHNvIGZvciBhIG5ldyBg bm90LWluLXJhbmdlYCBQRUcgcGF0dGVybiBmb3Igc2NoZW1lLgoKKiBtb2R1bGUvaWNlLTkv cGVnL2NvZGVnZW4uc2NtIChjZy1ub3QtaW4tcmFuZ2UpOiBOZXcgZnVuY3Rpb24uCiogbW9k dWxlL2ljZS05L3BlZy9zdHJpbmctcGVnLnNjbTogQWRkIHN1cHBvcnQgZm9yIGBbXi4uLl1g CiogdGVzdC1zdWl0ZS90ZXN0cy9wZWcudGVzdDogVGVzdCBpdC4KKiBkb2MvcmVmL2FwaS1w ZWcudGV4aTogRG9jdW1lbnQgYWNjb3JkaW5nbHkuCi0tLQogTkVXUyAgICAgICAgICAgICAg ICAgICAgICAgICAgICB8ICAzICsrLQogZG9jL3JlZi9hcGktcGVnLnRleGkgICAgICAgICAg ICB8ICA4ICsrKysrKysKIG1vZHVsZS9pY2UtOS9wZWcvY29kZWdlbi5zY20gICAgfCAyMiAr KysrKysrKysrKysrKysrKysrCiBtb2R1bGUvaWNlLTkvcGVnL3N0cmluZy1wZWcuc2NtIHwg MzggKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tCiB0ZXN0LXN1aXRlL3Rlc3Rz L3BlZy50ZXN0ICAgICAgIHwgIDYgKysrKystCiA1IGZpbGVzIGNoYW5nZWQsIDcyIGluc2Vy dGlvbnMoKyksIDUgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvTkVXUyBiL05FV1MKaW5k ZXggZGY0M2YzNzU0Li4xN2VmNTYwYjEgMTAwNjQ0Ci0tLSBhL05FV1MKKysrIGIvTkVXUwpA QCAtMzIsNyArMzIsOCBAQCBDaGFuZ2VzIGluIDMuMC4xMSAoc2luY2UgMy4wLjEwKQogKiog UEVHIHBhcnNlcgogCiBQRUcgcGFyc2VyIGhhcyBiZWVuIHJld3JpdHRlbiB0byBjb3ZlciBh bGwgdGhlIGZ1bmN0aW9uYWxpdHkgZGVmaW5lZCBpbgotPGh0dHBzOi8vYmZvcmQuaW5mby9w dWIvbGFuZy9wZWcucGRmPi4KKzxodHRwczovL2Jmb3JkLmluZm8vcHViL2xhbmcvcGVnLnBk Zj4uIEFsc28gYWRkZWQgdGhlIGBub3QtaW4tcmFuZ2VgIHBhdHRlcm4KK3RvIGAoaWNlLTkg cGVnKWAgdGhhdCBpcyBhbHNvIGF2YWlsYWJsZSBmcm9tIFBFRyBzdHJpbmdzIHZpYSBgW14u Li5dYC4KIAogDAogQ2hhbmdlcyBpbiAzLjAuMTAgKHNpbmNlIDMuMC45KQpkaWZmIC0tZ2l0 IGEvZG9jL3JlZi9hcGktcGVnLnRleGkgYi9kb2MvcmVmL2FwaS1wZWcudGV4aQppbmRleCA4 NGE5ZTZjNmIuLmVkYjA5MGIyMCAxMDA2NDQKLS0tIGEvZG9jL3JlZi9hcGktcGVnLnRleGkK KysrIGIvZG9jL3JlZi9hcGktcGVnLnRleGkKQEAgLTE0Nyw2ICsxNDcsMTQgQEAgUGFyc2Vz IGFueSBjaGFyYWN0ZXIgZmFsbGluZyBiZXR3ZWVuIEB2YXJ7YX0gYW5kIEB2YXJ7en0uCiBA Y29kZXsocmFuZ2UgI1xhICNceil9CiBAZW5kIGRlZnRwCiAKK0BkZWZ0cCB7UEVHIFBhdHRl cm59IHtpbnZlcnNlIHJhbmdlIG9mIGNoYXJhY3RlcnN9IGEgegorUGFyc2VzIGFueSBjaGFy YWN0ZXIgbm90IGZhbGxpbmcgYmV0d2VlbiBAdmFye2F9IGFuZCBAdmFye3p9LgorCitAY29k ZXsiW15hLXpdIn0KKworQGNvZGV7KG5vdC1pbi1yYW5nZSAjXGEgI1x6KX0KK0BlbmQgZGVm dHAKKwogRXhhbXBsZToKIAogQGV4YW1wbGUKZGlmZiAtLWdpdCBhL21vZHVsZS9pY2UtOS9w ZWcvY29kZWdlbi5zY20gYi9tb2R1bGUvaWNlLTkvcGVnL2NvZGVnZW4uc2NtCmluZGV4IGQ4 MGMzZTg0OS4uODIzNjdlZjU1IDEwMDY0NAotLS0gYS9tb2R1bGUvaWNlLTkvcGVnL2NvZGVn ZW4uc2NtCisrKyBiL21vZHVsZS9pY2UtOS9wZWcvY29kZWdlbi5zY20KQEAgLTE0MCw2ICsx NDAsMjcgQEAgcmV0dXJuIEVYUC4iCiAgICAgICAgICAgICAgICAgICAgICAgICAgKChub25l KSAjYChsaXN0ICgxKyBwb3MpICcoKSkpCiAgICAgICAgICAgICAgICAgICAgICAgICAgKGVs c2UgKGVycm9yICJiYWQgYWNjdW0iIGFjY3VtKSkpKSkpKSkpKQogCis7OyBHZW5lcmF0ZXMg Y29kZSBmb3IgbWF0Y2hpbmcgYSByYW5nZSBvZiBjaGFyYWN0ZXJzIG5vdCBiZXR3ZWVuIHN0 YXJ0IGFuZCBlbmQuCis7OyBFLmcuOiAoY2ctbm90LWluLXJhbmdlIHN5bnRheCAjXGEgI1x6 ICdib2R5KQorKGRlZmluZSAoY2ctbm90LWluLXJhbmdlIHBhdCBhY2N1bSkKKyAgKHN5bnRh eC1jYXNlIHBhdCAoKQorICAgICgoc3RhcnQgZW5kKQorICAgICAoaWYgKG5vdCAoYW5kIChj aGFyPyAoc3ludGF4LT5kYXR1bSAjJ3N0YXJ0KSkKKyAgICAgICAgICAgICAgICAgICAoY2hh cj8gKHN5bnRheC0+ZGF0dW0gIydlbmQpKSkpCisgICAgICAgICAoZXJyb3IgInJhbmdlIFBF RyBzaG91bGQgaGF2ZSBjaGFyYWN0ZXJzIGFmdGVyIGl0OyBpbnN0ZWFkIGdvdCIKKyAgICAg ICAgICAgICAgICAjJ3N0YXJ0ICMnZW5kKSkKKyAgICAgI2AobGFtYmRhIChzdHIgbGVuIHBv cykKKyAgICAgICAgIChhbmQgKDwgcG9zIGxlbikKKyAgICAgICAgICAgICAgKGxldCAoKGMg KHN0cmluZy1yZWYgc3RyIHBvcykpKQorICAgICAgICAgICAgICAgIChhbmQgKG9yIChjaGFy PD8gYyBzdGFydCkgKGNoYXI+PyBjIGVuZCkpCisgICAgICAgICAgICAgICAgICAgICAjLChj YXNlIGFjY3VtCisgICAgICAgICAgICAgICAgICAgICAgICAgKChhbGwpICNgKGxpc3QgKDEr IHBvcykKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAobGlzdCAn Y2ctbm90LWluLXJhbmdlIChzdHJpbmcgYykpKSkKKyAgICAgICAgICAgICAgICAgICAgICAg ICAoKG5hbWUpICNgKGxpc3QgKDErIHBvcykgJ2NnLW5vdC1pbi1yYW5nZSkpCisgICAgICAg ICAgICAgICAgICAgICAgICAgKChib2R5KSAjYChsaXN0ICgxKyBwb3MpIChzdHJpbmcgYykp KQorICAgICAgICAgICAgICAgICAgICAgICAgICgobm9uZSkgI2AobGlzdCAoMSsgcG9zKSAn KCkpKQorICAgICAgICAgICAgICAgICAgICAgICAgIChlbHNlIChlcnJvciAiYmFkIGFjY3Vt IiBhY2N1bSkpKSkpKSkpKSkKKwogOzsgR2VuZXJhdGUgY29kZSB0byBtYXRjaCBhIHBhdHRl cm4gYW5kIGRvIG5vdGhpbmcgd2l0aCB0aGUgcmVzdWx0CiAoZGVmaW5lIChjZy1pZ25vcmUg cGF0IGFjY3VtKQogICAoc3ludGF4LWNhc2UgcGF0ICgpCkBAIC0zMDQsNiArMzI1LDcgQEAg cmV0dXJuIEVYUC4iCiAgICAgICAgIChhc3NxLXNldCEgcGVnLWNvbXBpbGVyLWFsaXN0IHN5 bWJvbCBmdW5jdGlvbikpKQogCiAoYWRkLXBlZy1jb21waWxlciEgJ3JhbmdlIGNnLXJhbmdl KQorKGFkZC1wZWctY29tcGlsZXIhICdub3QtaW4tcmFuZ2UgY2ctbm90LWluLXJhbmdlKQog KGFkZC1wZWctY29tcGlsZXIhICdpZ25vcmUgY2ctaWdub3JlKQogKGFkZC1wZWctY29tcGls ZXIhICdjYXB0dXJlIGNnLWNhcHR1cmUpCiAoYWRkLXBlZy1jb21waWxlciEgJ2FuZCBjZy1h bmQpCmRpZmYgLS1naXQgYS9tb2R1bGUvaWNlLTkvcGVnL3N0cmluZy1wZWcuc2NtIGIvbW9k dWxlL2ljZS05L3BlZy9zdHJpbmctcGVnLnNjbQppbmRleCA0YjkyMzIyMGEuLjAwMjZmODkz MCAxMDA2NDQKLS0tIGEvbW9kdWxlL2ljZS05L3BlZy9zdHJpbmctcGVnLnNjbQorKysgYi9t b2R1bGUvaWNlLTkvcGVnL3N0cmluZy1wZWcuc2NtCkBAIC01NCw3ICs1NCw3IEBAIFByZWZp eCA8LS0gKEFORCAvIE5PVCk/IFN1ZmZpeAogU3VmZml4IDwtLSBQcmltYXJ5IChRVUVTVElP TiAvIFNUQVIgLyBQTFVTKT8KIFByaW1hcnkgPC0tIElkZW50aWZpZXIgIUxFRlRBUlJPVwog ICAgICAgICAgICAvIE9QRU4gRXhwcmVzc2lvbiBDTE9TRQotICAgICAgICAgICAvIExpdGVy YWwgLyBDbGFzcyAvIERPVAorICAgICAgICAgICAvIExpdGVyYWwgLyBDbGFzcyAvIE5vdElu Q2xhc3MgLyBET1QKIAogIyBMZXhpY2FsIHN5bnRheAogSWRlbnRpZmllciA8LS0gSWRlbnRT dGFydCBJZGVudENvbnQqIFNwYWNpbmcKQEAgLTY0LDYgKzY0LDcgQEAgSWRlbnRDb250IDwt IElkZW50U3RhcnQgLyBbMC05XQogCiBMaXRlcmFsIDwtLSBTUVVPVEUgKCFTUVVPVEUgQ2hh cikqIFNRVU9URSBTcGFjaW5nCiAgICAgICAgIC8gRFFVT1RFICghRFFVT1RFIENoYXIpKiBE UVVPVEUgU3BhY2luZworTm90SW5DbGFzcyA8LS0gT1BFTkJSQUNLRVQgTk9USU4gICghQ0xP U0VCUkFDS0VUIFJhbmdlKSogQ0xPU0VCUkFDS0VUIFNwYWNpbmcKIENsYXNzIDwtLSBPUEVO QlJBQ0tFVCAhTk9USU4gICghQ0xPU0VCUkFDS0VUIFJhbmdlKSogQ0xPU0VCUkFDS0VUIFNw YWNpbmcKIFJhbmdlIDwtLSBDaGFyIERBU0ggQ2hhciAvIENoYXIKIENoYXIgPC0tICdcXFxc JyBbbnJ0J1wiXFxbXFxdXFxcXF0KQEAgLTc4LDYgKzc5LDcgQEAgRFFVT1RFIDwgW1wiXQog REFTSCA8ICctJwogT1BFTkJSQUNLRVQgPCAnWycKIENMT1NFQlJBQ0tFVCA8ICddJworTk9U SU4gPCAnXicKIFNMQVNIIDwgJy8nIFNwYWNpbmcKIEFORCA8LS0gJyYnIFNwYWNpbmcKIE5P VCA8LS0gJyEnIFNwYWNpbmcKQEAgLTEyMiw2ICsxMjQsNyBAQCBFbmRPZkZpbGUgPCAhLgog ICAgICAgKGFuZCBPUEVOIEV4cHJlc3Npb24gQ0xPU0UpCiAgICAgICBMaXRlcmFsCiAgICAg ICBDbGFzcworICAgICAgTm90SW5DbGFzcwogICAgICAgRE9UKSkKIChkZWZpbmUtc2V4cC1w YXJzZXIgSWRlbnRpZmllciBhbGwKICAgKGFuZCBJZGVudFN0YXJ0ICgqIElkZW50Q29udCkg U3BhY2luZykpCkBAIC0xMzMsNyArMTM2LDExIEBAIEVuZE9mRmlsZSA8ICEuCiAgIChvciAo YW5kIFNRVU9URSAoKiAoYW5kIChub3QtZm9sbG93ZWQtYnkgU1FVT1RFKSBDaGFyKSkgU1FV T1RFIFNwYWNpbmcpCiAgICAgICAoYW5kIERRVU9URSAoKiAoYW5kIChub3QtZm9sbG93ZWQt YnkgRFFVT1RFKSBDaGFyKSkgRFFVT1RFIFNwYWNpbmcpKSkKIChkZWZpbmUtc2V4cC1wYXJz ZXIgQ2xhc3MgYWxsCi0gIChhbmQgT1BFTkJSQUNLRVQgKCogKGFuZCAobm90LWZvbGxvd2Vk LWJ5IENMT1NFQlJBQ0tFVCkgUmFuZ2UpKSBDTE9TRUJSQUNLRVQgU3BhY2luZykpCisgIChh bmQgT1BFTkJSQUNLRVQgKG5vdC1mb2xsb3dlZC1ieSBOT1RJTikKKyAgICAgICAoKiAoYW5k IChub3QtZm9sbG93ZWQtYnkgQ0xPU0VCUkFDS0VUKSBSYW5nZSkpIENMT1NFQlJBQ0tFVCBT cGFjaW5nKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgTm90SW5DbGFzcyBhbGwKKyAgKGFuZCBP UEVOQlJBQ0tFVCBOT1RJTgorICAgICAgICgqIChhbmQgKG5vdC1mb2xsb3dlZC1ieSBDTE9T RUJSQUNLRVQpIFJhbmdlKSkgQ0xPU0VCUkFDS0VUIFNwYWNpbmcpKQogKGRlZmluZS1zZXhw LXBhcnNlciBSYW5nZSBhbGwKICAgKG9yIChhbmQgQ2hhciBEQVNIIENoYXIpIENoYXIpKQog KGRlZmluZS1zZXhwLXBhcnNlciBDaGFyIGFsbApAQCAtMTQzLDYgKzE1MCw4IEBAIEVuZE9m RmlsZSA8ICEuCiAgICAgICAoYW5kIChub3QtZm9sbG93ZWQtYnkgIlxcIikgcGVnLWFueSkp KQogKGRlZmluZS1zZXhwLXBhcnNlciBMRUZUQVJST1cgYm9keQogICAoYW5kIChvciAiPC0t IiAiPC0iICI8IikgU3BhY2luZykpIDsgTk9URTogPC0tIGFuZCA8IGFyZSBleHRlbnNpb25z CisoZGVmaW5lLXNleHAtcGFyc2VyIE5PVElOIG5vbmUKKyAgKGFuZCAiXiIpKQogKGRlZmlu ZS1zZXhwLXBhcnNlciBTTEFTSCBub25lCiAgIChhbmQgIi8iIFNwYWNpbmcpKQogKGRlZmlu ZS1zZXhwLXBhcnNlciBBTkQgYWxsCkBAIC0yNzksNiArMjg4LDcgQEAgRW5kT2ZGaWxlIDwg IS4KICAgICAgICgnSWRlbnRpZmllciAoSWRlbnRpZmllci0+ZGVmbiB2YWx1ZSBmb3Itc3lu dGF4KSkKICAgICAgICgnRXhwcmVzc2lvbiAoRXhwcmVzc2lvbi0+ZGVmbiB2YWx1ZSBmb3It c3ludGF4KSkKICAgICAgICgnTGl0ZXJhbCAgICAoTGl0ZXJhbC0+ZGVmbiB2YWx1ZSBmb3It c3ludGF4KSkKKyAgICAgICgnTm90SW5DbGFzcyAoTm90SW5DbGFzcy0+ZGVmbiB2YWx1ZSBm b3Itc3ludGF4KSkKICAgICAgICgnQ2xhc3MgICAgICAoQ2xhc3MtPmRlZm4gdmFsdWUgZm9y LXN5bnRheCkpKSkpCiAKIDs7IChJZGVudGlmaWVyICJoZWxsbyIpCkBAIC0yOTEsMTMgKzMw MSwzNSBAQCBFbmRPZkZpbGUgPCAhLgogKGRlZmluZSAoTGl0ZXJhbC0+ZGVmbiBsc3QgZm9y LXN5bnRheCkKICAgKGFwcGx5IHN0cmluZyAobWFwIChsYW1iZGEgKHgpIChDaGFyLT5kZWZu IHggZm9yLXN5bnRheCkpIChjZHIgbHN0KSkpKQogCi07OyBUT0RPOiBlbXB0eSBDbGFzcyBj YW4gaGFwcGVuOiBgW11gLCBidXQgd2hhdCBkb2VzIGl0IHJlcHJlc2VudD8KKzs7IChOb3RJ bkNsYXNzIC4uLikKKzs7ICBgLT4gKGFuZCAuLi4pCisoZGVmaW5lIChOb3RJbkNsYXNzLT5k ZWZuIGxzdCBmb3Itc3ludGF4KQorICAjYChhbmQgIyxAKG1hcCAobGFtYmRhICh4KSAoTm90 SW5SYW5nZS0+ZGVmbiB4IGZvci1zeW50YXgpKQorICAgICAgICAgICAgICAgICAoY2RyIGxz dCkpKSkKKwogOzsgKENsYXNzIC4uLikKIDs7ICBgLT4gKG9yIC4uLikKIChkZWZpbmUgKENs YXNzLT5kZWZuIGxzdCBmb3Itc3ludGF4KQogICAjYChvciAjLEAobWFwIChsYW1iZGEgKHgp IChSYW5nZS0+ZGVmbiB4IGZvci1zeW50YXgpKQogICAgICAgICAgICAgICAgIChjZHIgbHN0 KSkpKQogCis7OyBOT1RFOiBJdCdzIGNvbWluZyBmcm9tIE5vdEluQ2xhc3MuCis7OyBGb3Ig b25lIGNoYXJhY3RlcjoKKzs7IChSYW5nZSAoQ2hhciAiYSIpKQorOzsgIGAtPiAobm90LWlu LXJhbmdlICNcYSAjXGEpCis7OyBPciBmb3IgYSByYW5nZToKKzs7IChSYW5nZSAoQ2hhciAi YSIpIChDaGFyICJiIikpCis7OyAgYC0+IChub3QtaW4tcmFuZ2UgI1xhICNcYikKKyhkZWZp bmUgKE5vdEluUmFuZ2UtPmRlZm4gbHN0IGZvci1zeW50YXgpCisgIChtYXRjaCBsc3QKKyAg ICAoKCdSYW5nZSBjKQorICAgICAobGV0ICgoY2ggKENoYXItPmRlZm4gYyBmb3Itc3ludGF4 KSkpCisgICAgICAgI2Aobm90LWluLXJhbmdlICMsY2ggIyxjaCkpKQorICAgICgoJ1Jhbmdl IHJhbmdlLWJlZ2lubmluZyByYW5nZS1lbmQpCisgICAgICNgKG5vdC1pbi1yYW5nZQorICAg ICAgICAgIywoQ2hhci0+ZGVmbiByYW5nZS1iZWdpbm5pbmcgZm9yLXN5bnRheCkKKyAgICAg ICAgICMsKENoYXItPmRlZm4gcmFuZ2UtZW5kICAgICAgIGZvci1zeW50YXgpKSkpKQorCiA7 OyBGb3Igb25lIGNoYXJhY3RlcjoKIDs7IChSYW5nZSAoQ2hhciAiYSIpKQogOzsgIGAtPiAi YSIKZGlmZiAtLWdpdCBhL3Rlc3Qtc3VpdGUvdGVzdHMvcGVnLnRlc3QgYi90ZXN0LXN1aXRl L3Rlc3RzL3BlZy50ZXN0CmluZGV4IDExMzZjMDNmMS4uZDllM2UxYjIyIDEwMDY0NAotLS0g YS90ZXN0LXN1aXRlL3Rlc3RzL3BlZy50ZXN0CisrKyBiL3Rlc3Qtc3VpdGUvdGVzdHMvcGVn LnRlc3QKQEAgLTM4LDYgKzM4LDcgQEAKICAgICAoSWRlbnRpZmllciBJZGVudGlmaWVyKQog ICAgIChMaXRlcmFsIExpdGVyYWwpCiAgICAgKENsYXNzIENsYXNzKQorICAgIChOb3RJbkNs YXNzIE5vdEluQ2xhc3MpCiAgICAgKFJhbmdlIFJhbmdlKQogICAgIChDaGFyIENoYXIpCiAg ICAgKExFRlRBUlJPVyBMRUZUQVJST1cpCkBAIC04NSw3ICs4Niw3IEBACiBFbmQgPC0tICcq KScKIEMgPC0gQmVnaW4gTiogRW5kCiBOIDwtIEMgLyAoIUJlZ2luICFFbmQgWikKLVogPC0g LiIpCitaIDwtIFteWC1aXSIpIDs7IEZvcmJpZCBzb21lIGNoYXJhY3RlcnMgdG8gdGVzdCBu b3QtaW4tcmFuZ2UKIAogOzsgQSBzaG9ydCAvZXRjL3Bhc3N3ZCBmaWxlLgogKGRlZmluZSAq ZXRjLXBhc3N3ZCoKQEAgLTEyNSw2ICsxMjYsOSBAQCBTTEFTSCA8ICcvJyIpCiAgICAgKG1h dGNoLXBhdHRlcm4gQyAiKCpibGFoKikiKQogICAgIChtYWtlLXByZWMgMCA4ICIoKmJsYWgq KSIKIAkgICAgICAgJygoQmVnaW4gIigqIikgImJsYWgiIChFbmQgIiopIikpKSkpCisgIChw YXNzLWlmCisgICAic2ltcGxlIGNvbW1lbnQgd2l0aCBmb3JiaWRkZW4gY2hhciIKKyAgIChu b3QgKG1hdGNoLXBhdHRlcm4gQyAiKCpibFloKikiKSkpCiAgIChwYXNzLWlmCiAgICAic2lt cGxlIGNvbW1lbnQgcGFkZGVkIgogICAgKGVxdWFsPwotLSAKMi40Ni4wCgo= --------------QKBL2uiBJnbd9YBTHqXA1fU1 Content-Type: text/x-patch; charset=UTF-8; name="v4-0001-PEG-Add-full-support-for-PEG-some-extensions.patch" Content-Disposition: attachment; filename*0="v4-0001-PEG-Add-full-support-for-PEG-some-extensions.patch" Content-Transfer-Encoding: base64 RnJvbSA0NTlkODNlYzI3MTBiZWQ1ZmViM2QyYTljYTI4ZGE4ZWRlOWRhMDA3IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBFa2FpdHogWmFycmFnYSA8ZWthaXR6QGVsZW5xLnRl Y2g+CkRhdGU6IFdlZCwgMTEgU2VwIDIwMjQgMjE6MTk6MjYgKzAyMDAKU3ViamVjdDogW1BB VENIIHY0IDEvMl0gUEVHOiBBZGQgZnVsbCBzdXBwb3J0IGZvciBQRUcgKyBzb21lIGV4dGVu c2lvbnMKClRoaXMgY29tbWl0IGFkZHMgc3VwcG9ydCBmb3IgUEVHIGFzIGRlc2NyaWJlZCBp bjoKCiAgICA8aHR0cHM6Ly9iZm9yZC5pbmZvL3B1Yi9sYW5nL3BlZy5wZGY+CgpJdCBhZGRz IHN1cHBvcnQgZm9yIHRoZSBtaXNzaW5nIGZlYXR1cmVzIChjb21tZW50cywgdW5kZXJzY29y ZXMgaW4KaWRlbnRpZmllcnMgYW5kIGVzY2FwaW5nKSB3aGlsZSBrZWVwaW5nIHRoZSBleHRl bnNpb25zIChkYXNoZXMgaW4KaWRlbnRpZmllcnMsIDwgYW5kIDwtLSkuCgpUaGUgbmFtaW5n IHN5c3RlbSB0cmllcyB0byBiZSBhcyBjbG9zZSBhcyBwb3NzaWJsZSB0byB0aGUgb25lIHBy b3Bvc2VkCmluIHRoZSBwYXBlci4KCiogbW9kdWxlL2ljZS05L3BlZy9zdHJpbmctcGVnLnNj bTogUmV3cml0ZSBQRUcgcGFyc2VyLgoqIHRlc3Qtc3VpdGUvdGVzdHMvcGVnLnRlc3Q6IEZp eCBpbXBvcnQKLS0tCiBORVdTICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICA3ICsK IGRvYy9yZWYvYXBpLXBlZy50ZXhpICAgICAgICAgICAgfCAgIDggKy0KIG1vZHVsZS9pY2Ut OS9wZWcvc3RyaW5nLXBlZy5zY20gfCA0NDYgKysrKysrKysrKysrKysrKysrKystLS0tLS0t LS0tLS0KIHRlc3Qtc3VpdGUvdGVzdHMvcGVnLnRlc3QgICAgICAgfCAgMzIgKystCiA0IGZp bGVzIGNoYW5nZWQsIDMxMyBpbnNlcnRpb25zKCspLCAxODAgZGVsZXRpb25zKC0pCgpkaWZm IC0tZ2l0IGEvTkVXUyBiL05FV1MKaW5kZXggOWZkMTRjMzlkLi5kZjQzZjM3NTQgMTAwNjQ0 Ci0tLSBhL05FV1MKKysrIGIvTkVXUwpAQCAtMjcsNiArMjcsMTMgQEAgQ2hhbmdlcyBpbiAz LjAuMTEgKHNpbmNlIDMuMC4xMCkKICoqIEd1aWxlIGlzIGNvbXBpbGVkIHdpdGggLWZleGNl c3MtcHJlY2lzaW9uPXN0YW5kYXJkIGZvciBpWzM0NTZdODYgd2hlbiBwb3NzaWJsZQogICAg KDxodHRwczovL2RlYmJ1Z3MuZ251Lm9yZy80MzI2Mj4pCiAKKyogTmV3IGludGVyZmFjZXMg YW5kIGZ1bmN0aW9uYWxpdHkKKworKiogUEVHIHBhcnNlcgorCitQRUcgcGFyc2VyIGhhcyBi ZWVuIHJld3JpdHRlbiB0byBjb3ZlciBhbGwgdGhlIGZ1bmN0aW9uYWxpdHkgZGVmaW5lZCBp bgorPGh0dHBzOi8vYmZvcmQuaW5mby9wdWIvbGFuZy9wZWcucGRmPi4KKwogDAogQ2hhbmdl cyBpbiAzLjAuMTAgKHNpbmNlIDMuMC45KQogCmRpZmYgLS1naXQgYS9kb2MvcmVmL2FwaS1w ZWcudGV4aSBiL2RvYy9yZWYvYXBpLXBlZy50ZXhpCmluZGV4IGQzNGRkYzY0Yy4uODRhOWU2 YzZiIDEwMDY0NAotLS0gYS9kb2MvcmVmL2FwaS1wZWcudGV4aQorKysgYi9kb2MvcmVmL2Fw aS1wZWcudGV4aQpAQCAtMTcsNiArMTcsMTAgQEAgV2lraXBlZGlhIGhhcyBhIGNsZWFyIGFu ZCBjb25jaXNlIGludHJvZHVjdGlvbiB0byBQRUdzIGlmIHlvdSB3YW50IHRvCiBmYW1pbGlh cml6ZSB5b3Vyc2VsZiB3aXRoIHRoZSBzeW50YXg6CiBAdXJse2h0dHA6Ly9lbi53aWtpcGVk aWEub3JnL3dpa2kvUGFyc2luZ19leHByZXNzaW9uX2dyYW1tYXJ9LgogCitUaGUgcGFwZXIg dGhhdCBpbnRyb2R1Y2VkIFBFRyBjb250YWlucyBhIG1vcmUgZGV0YWlsZWQgZGVzY3JpcHRp b24gb2YgaG93IFBFRword29ya3MsIGFuZCBkZXNjcmliZXMgaXRzIHN5bnRheCBpbiBkZXRh aWw6CitAdXJse2h0dHBzOi8vYmZvcmQuaW5mby9wdWIvbGFuZy9wZWcucGRmfQorCiBUaGUg QGNvZGV7KGljZS05IHBlZyl9IG1vZHVsZSB3b3JrcyBieSBjb21waWxpbmcgUEVHcyBkb3du IHRvIGxhbWJkYQogZXhwcmVzc2lvbnMuICBUaGVzZSBjYW4gZWl0aGVyIGJlIHN0b3JlZCBp biB2YXJpYWJsZXMgYXQgY29tcGlsZS10aW1lIGJ5CiB0aGUgZGVmaW5lIG1hY3JvcyAoQGNv ZGV7ZGVmaW5lLXBlZy1wYXR0ZXJufSBhbmQKQEAgLTIxNiw4ICsyMjAsOCBAQCBzaG91bGQg cHJvcGFnYXRlIHVwIHRoZSBwYXJzZSB0cmVlLiAgVGhlIG5vcm1hbCBAY29kZXs8LX0gcHJv cGFnYXRlcyB0aGUKIG1hdGNoZWQgdGV4dCB1cCB0aGUgcGFyc2UgdHJlZSwgQGNvZGV7PC0t fSBwcm9wYWdhdGVzIHRoZSBtYXRjaGVkIHRleHQKIHVwIHRoZSBwYXJzZSB0cmVlIHRhZ2dl ZCB3aXRoIHRoZSBuYW1lIG9mIHRoZSBub250ZXJtaW5hbCwgYW5kIEBjb2Rlezx9CiBkaXNj YXJkcyB0aGF0IG1hdGNoZWQgdGV4dCBhbmQgcHJvcGFnYXRlcyBub3RoaW5nIHVwIHRoZSBw YXJzZSB0cmVlLgotQWxzbywgbm9udGVybWluYWxzIG1heSBjb25zaXN0IG9mIGFueSBhbHBo YW51bWVyaWMgY2hhcmFjdGVyIG9yIGEgYGAtJycKLWNoYXJhY3RlciAoaW4gbm9ybWFsIFBF R3Mgbm9udGVybWluYWxzIGNhbiBvbmx5IGJlIGFscGhhYmV0aWMpLgorQWxzbywgbm9udGVy bWluYWxzIG1heSBpbmNsdWRlIGBgLScnIGNoYXJhY3Rlciwgd2hpbGUgaW4gbm9ybWFsIFBF RyBpdCBpcyBub3QKK2FsbG93ZWQuCiAKIEZvciBleGFtcGxlLCBpZiB3ZToKIEBsaXNwCmRp ZmYgLS1naXQgYS9tb2R1bGUvaWNlLTkvcGVnL3N0cmluZy1wZWcuc2NtIGIvbW9kdWxlL2lj ZS05L3BlZy9zdHJpbmctcGVnLnNjbQppbmRleCA0NWVkMTRiYjEuLjRiOTIzMjIwYSAxMDA2 NDQKLS0tIGEvbW9kdWxlL2ljZS05L3BlZy9zdHJpbmctcGVnLnNjbQorKysgYi9tb2R1bGUv aWNlLTkvcGVnL3N0cmluZy1wZWcuc2NtCkBAIC0xLDYgKzEsNyBAQAogOzs7OyBzdHJpbmct cGVnLnNjbSAtLS0gcmVwcmVzZW50aW5nIFBFRyBncmFtbWFycyBhcyBzdHJpbmdzCiA7Ozs7 Ci07Ozs7IAlDb3B5cmlnaHQgKEMpIDIwMTAsIDIwMTEgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uLCBJbmMuCis7Ozs7IAlDb3B5cmlnaHQgKEMpIDIwMTAsIDIwMTEsIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbiwgSW5jLgorOzs7OyAJQ29weXJpZ2h0IChDKSAyMDI0IEVrYWl0eiBa YXJyYWdhIDxla2FpdHpAZWxlbnEudGVjaD4KIDs7OzsKIDs7OzsgVGhpcyBsaWJyYXJ5IGlz IGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogOzs7OyBt b2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVi bGljCkBAIC0yMSwxMCArMjIsMTUgQEAKICAgIzpleHBvcnQgKHBlZy1hcy1wZWcKICAgICAg ICAgICAgIGRlZmluZS1wZWctc3RyaW5nLXBhdHRlcm5zCiAgICAgICAgICAgICBwZWctZ3Jh bW1hcikKKyAgIzp1c2UtbW9kdWxlIChpY2UtOSBtYXRjaCkKICAgIzp1c2UtbW9kdWxlIChp Y2UtOSBwZWcgdXNpbmctcGFyc2VycykKKyAgIzp1c2UtbW9kdWxlIChzcmZpIHNyZmktMSkK ICAgIzp1c2UtbW9kdWxlIChpY2UtOSBwZWcgY29kZWdlbikKICAgIzp1c2UtbW9kdWxlIChp Y2UtOSBwZWcgc2ltcGxpZnktdHJlZSkpCiAKKzs7IFRoaXMgbW9kdWxlIHByb3ZpZGVzIHN1 cHBvcnQgZm9yIFBFRyBhcyBkZXNjcmliZWQgaW46Cis7OyAgIDxodHRwczovL2Jmb3JkLmlu Zm8vcHViL2xhbmcvcGVnLnBkZj4KKwogOzsgR2V0cyB0aGUgbGVmdC1oYW5kIGRlcHRoIG9m IGEgbGlzdC4KIChkZWZpbmUgKGRlcHRoIGxzdCkKICAgKGlmIChvciAobm90IChsaXN0PyBs c3QpKSAobnVsbD8gbHN0KSkKQEAgLTM4LDIyICs0NCw1OCBAQAogCiA7OyBHcmFtbWFyIGZv ciBQRUdzIGluIFBFRyBncmFtbWFyLgogKGRlZmluZSBwZWctYXMtcGVnCi0iZ3JhbW1hciA8 LS0gKG5vbnRlcm1pbmFsICgnPC0tJyAvICc8LScgLyAnPCcpIHNwIHBhdHRlcm4pKwotcGF0 dGVybiA8LS0gYWx0ZXJuYXRpdmUgKFNMQVNIIHNwIGFsdGVybmF0aXZlKSoKLWFsdGVybmF0 aXZlIDwtLSAoWyEmXT8gc3Agc3VmZml4KSsKLXN1ZmZpeCA8LS0gcHJpbWFyeSAoWyorP10g c3ApKgotcHJpbWFyeSA8LS0gJygnIHNwIHBhdHRlcm4gJyknIHNwIC8gJy4nIHNwIC8gbGl0 ZXJhbCAvIGNoYXJjbGFzcyAvIG5vbnRlcm1pbmFsICEnPCcKLWxpdGVyYWwgPC0tIFsnXSAo IVsnXSAuKSogWyddIHNwCi1jaGFyY2xhc3MgPC0tIExCICghJ10nIChDQ3JhbmdlIC8gQ0Nz aW5nbGUpKSogUkIgc3AKLUNDcmFuZ2UgPC0tIC4gJy0nIC4KLUNDc2luZ2xlIDwtLSAuCi1u b250ZXJtaW5hbCA8LS0gW2EtekEtWjAtOS1dKyBzcAotc3AgPCBbIFx0XG5dKgotU0xBU0gg PCAnLycKLUxCIDwgJ1snCi1SQiA8ICddJworIiMgSGllcmFyY2hpY2FsIHN5bnRheAorR3Jh bW1hciA8LS0gU3BhY2luZyBEZWZpbml0aW9uKyBFbmRPZkZpbGUKK0RlZmluaXRpb24gPC0t IElkZW50aWZpZXIgTEVGVEFSUk9XIEV4cHJlc3Npb24KKworRXhwcmVzc2lvbiA8LS0gU2Vx dWVuY2UgKFNMQVNIIFNlcXVlbmNlKSoKK1NlcXVlbmNlIDwtLSBQcmVmaXgqCitQcmVmaXgg PC0tIChBTkQgLyBOT1QpPyBTdWZmaXgKK1N1ZmZpeCA8LS0gUHJpbWFyeSAoUVVFU1RJT04g LyBTVEFSIC8gUExVUyk/CitQcmltYXJ5IDwtLSBJZGVudGlmaWVyICFMRUZUQVJST1cKKyAg ICAgICAgICAgLyBPUEVOIEV4cHJlc3Npb24gQ0xPU0UKKyAgICAgICAgICAgLyBMaXRlcmFs IC8gQ2xhc3MgLyBET1QKKworIyBMZXhpY2FsIHN5bnRheAorSWRlbnRpZmllciA8LS0gSWRl bnRTdGFydCBJZGVudENvbnQqIFNwYWNpbmcKKyMgTk9URTogYC1gIGlzIGFuIGV4dGVuc2lv bgorSWRlbnRTdGFydCA8LSBbYS16QS1aX10gLyAnLScKK0lkZW50Q29udCA8LSBJZGVudFN0 YXJ0IC8gWzAtOV0KKworTGl0ZXJhbCA8LS0gU1FVT1RFICghU1FVT1RFIENoYXIpKiBTUVVP VEUgU3BhY2luZworICAgICAgICAvIERRVU9URSAoIURRVU9URSBDaGFyKSogRFFVT1RFIFNw YWNpbmcKK0NsYXNzIDwtLSBPUEVOQlJBQ0tFVCAhTk9USU4gICghQ0xPU0VCUkFDS0VUIFJh bmdlKSogQ0xPU0VCUkFDS0VUIFNwYWNpbmcKK1JhbmdlIDwtLSBDaGFyIERBU0ggQ2hhciAv IENoYXIKK0NoYXIgPC0tICdcXFxcJyBbbnJ0J1wiXFxbXFxdXFxcXF0KKyAgICAgICAvICdc XFxcJyBbMC03XVswLTddWzAtN10KKyAgICAgICAvICdcXFxcJyBbMC03XVswLTddPworICAg ICAgIC8gISdcXFxcJyAuCisKKyMgTk9URTogYDwtLWAgYW5kIGA8YCBhcmUgZXh0ZW5zaW9u cworTEVGVEFSUk9XIDwtICgnPC0tJyAvICc8LScgLyAnPCcpIFNwYWNpbmcKK1NRVU9URSA8 IFsnXQorRFFVT1RFIDwgW1wiXQorREFTSCA8ICctJworT1BFTkJSQUNLRVQgPCAnWycKK0NM T1NFQlJBQ0tFVCA8ICddJworU0xBU0ggPCAnLycgU3BhY2luZworQU5EIDwtLSAnJicgU3Bh Y2luZworTk9UIDwtLSAnIScgU3BhY2luZworUVVFU1RJT04gPC0tICc/JyBTcGFjaW5nCitT VEFSIDwtLSAnKicgU3BhY2luZworUExVUyA8LS0gJysnIFNwYWNpbmcKK09QRU4gPCAnKCcg U3BhY2luZworQ0xPU0UgPCAnKScgU3BhY2luZworRE9UIDwtLSAnLicgU3BhY2luZworCitT cGFjaW5nIDwgKFNwYWNlIC8gQ29tbWVudCkqCitDb21tZW50IDwgJyMnICghRW5kT2ZMaW5l IC4pKiBFbmRPZkxpbmUKK1NwYWNlIDwgJyAnIC8gJ1x0JyAvIEVuZE9mTGluZQorRW5kT2ZM aW5lIDwgJ1xcclxcbicgLyAnXFxuJyAvICdcXHInCitFbmRPZkZpbGUgPCAhLgogIikKIAor CiAoZGVmaW5lLXN5bnRheCBkZWZpbmUtc2V4cC1wYXJzZXIKICAgKGxhbWJkYSAoeCkKICAg ICAoc3ludGF4LWNhc2UgeCAoKQpAQCAtNjMsMzUgKzEwNSw3OCBAQCBSQiA8ICddJwogICAg ICAgICAgICAgICAoc3luICh3cmFwLXBhcnNlci1mb3ItdXNlcnMgeCBtYXRjaGYgYWNjdW1z eW0gIydzeW0pKSkKICAgICAgICAgICAgI2AoZGVmaW5lIHN5bSAjLHN5bikpKSkpKQogCi0o ZGVmaW5lLXNleHAtcGFyc2VyIHBlZy1ncmFtbWFyIGFsbAotICAoKyAoYW5kIHBlZy1ub250 ZXJtaW5hbCAob3IgIjwtLSIgIjwtIiAiPCIpIHBlZy1zcCBwZWctcGF0dGVybikpKQotKGRl ZmluZS1zZXhwLXBhcnNlciBwZWctcGF0dGVybiBhbGwKLSAgKGFuZCBwZWctYWx0ZXJuYXRp dmUKLSAgICAgICAoKiAoYW5kIChpZ25vcmUgIi8iKSBwZWctc3AgcGVnLWFsdGVybmF0aXZl KSkpKQotKGRlZmluZS1zZXhwLXBhcnNlciBwZWctYWx0ZXJuYXRpdmUgYWxsCi0gICgrIChh bmQgKD8gKG9yICIhIiAiJiIpKSBwZWctc3AgcGVnLXN1ZmZpeCkpKQotKGRlZmluZS1zZXhw LXBhcnNlciBwZWctc3VmZml4IGFsbAotICAoYW5kIHBlZy1wcmltYXJ5ICgqIChhbmQgKG9y ICIqIiAiKyIgIj8iKSBwZWctc3ApKSkpCi0oZGVmaW5lLXNleHAtcGFyc2VyIHBlZy1wcmlt YXJ5IGFsbAotICAob3IgKGFuZCAiKCIgcGVnLXNwIHBlZy1wYXR0ZXJuICIpIiBwZWctc3Ap Ci0gICAgICAoYW5kICIuIiBwZWctc3ApCi0gICAgICBwZWctbGl0ZXJhbAotICAgICAgcGVn LWNoYXJjbGFzcwotICAgICAgKGFuZCBwZWctbm9udGVybWluYWwgKG5vdC1mb2xsb3dlZC1i eSAiPCIpKSkpCi0oZGVmaW5lLXNleHAtcGFyc2VyIHBlZy1saXRlcmFsIGFsbAotICAoYW5k ICInIiAoKiAoYW5kIChub3QtZm9sbG93ZWQtYnkgIiciKSBwZWctYW55KSkgIiciIHBlZy1z cCkpCi0oZGVmaW5lLXNleHAtcGFyc2VyIHBlZy1jaGFyY2xhc3MgYWxsCi0gIChhbmQgKGln bm9yZSAiWyIpCi0gICAgICAgKCogKGFuZCAobm90LWZvbGxvd2VkLWJ5ICJdIikKLSAgICAg ICAgICAgICAgIChvciBjaGFyY2xhc3MtcmFuZ2UgY2hhcmNsYXNzLXNpbmdsZSkpKQotICAg ICAgIChpZ25vcmUgIl0iKQotICAgICAgIHBlZy1zcCkpCi0oZGVmaW5lLXNleHAtcGFyc2Vy IGNoYXJjbGFzcy1yYW5nZSBhbGwgKGFuZCBwZWctYW55ICItIiBwZWctYW55KSkKLShkZWZp bmUtc2V4cC1wYXJzZXIgY2hhcmNsYXNzLXNpbmdsZSBhbGwgcGVnLWFueSkKLShkZWZpbmUt c2V4cC1wYXJzZXIgcGVnLW5vbnRlcm1pbmFsIGFsbAotICAoYW5kICgrIChvciAocmFuZ2Ug I1xhICNceikgKHJhbmdlICNcQSAjXFopIChyYW5nZSAjXDAgI1w5KSAiLSIpKSBwZWctc3Ap KQotKGRlZmluZS1zZXhwLXBhcnNlciBwZWctc3Agbm9uZQotICAoKiAob3IgIiAiICJcdCIg IlxuIikpKQorKGRlZmluZS1zZXhwLXBhcnNlciBHcmFtbWFyIGFsbAorICAoYW5kIFNwYWNp bmcgKCsgRGVmaW5pdGlvbikgRW5kT2ZGaWxlKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgRGVm aW5pdGlvbiBhbGwKKyAgKGFuZCBJZGVudGlmaWVyIExFRlRBUlJPVyBFeHByZXNzaW9uKSkK KyhkZWZpbmUtc2V4cC1wYXJzZXIgRXhwcmVzc2lvbiBhbGwKKyAgKGFuZCBTZXF1ZW5jZSAo KiAoYW5kIFNMQVNIIFNlcXVlbmNlKSkpKQorKGRlZmluZS1zZXhwLXBhcnNlciBTZXF1ZW5j ZSBhbGwKKyAgKCogUHJlZml4KSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgUHJlZml4IGFsbAor ICAoYW5kICg/IChvciBBTkQgTk9UKSkgU3VmZml4KSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIg U3VmZml4IGFsbAorICAoYW5kIFByaW1hcnkgKD8gKG9yIFFVRVNUSU9OIFNUQVIgUExVUykp KSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgUHJpbWFyeSBhbGwKKyAgKG9yIChhbmQgSWRlbnRp ZmllciAobm90LWZvbGxvd2VkLWJ5IExFRlRBUlJPVykpCisgICAgICAoYW5kIE9QRU4gRXhw cmVzc2lvbiBDTE9TRSkKKyAgICAgIExpdGVyYWwKKyAgICAgIENsYXNzCisgICAgICBET1Qp KQorKGRlZmluZS1zZXhwLXBhcnNlciBJZGVudGlmaWVyIGFsbAorICAoYW5kIElkZW50U3Rh cnQgKCogSWRlbnRDb250KSBTcGFjaW5nKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgSWRlbnRT dGFydCBib2R5CisgIChvciAob3IgKHJhbmdlICNcYSAjXHopIChyYW5nZSAjXEEgI1xaKSAi XyIpICItIikpIDsgTk9URTogLSBpcyBhbiBleHRlbnNpb24KKyhkZWZpbmUtc2V4cC1wYXJz ZXIgSWRlbnRDb250IGJvZHkKKyAgKG9yIElkZW50U3RhcnQgKHJhbmdlICNcMCAjXDkpKSkK KyhkZWZpbmUtc2V4cC1wYXJzZXIgTGl0ZXJhbCBhbGwKKyAgKG9yIChhbmQgU1FVT1RFICgq IChhbmQgKG5vdC1mb2xsb3dlZC1ieSBTUVVPVEUpIENoYXIpKSBTUVVPVEUgU3BhY2luZykK KyAgICAgIChhbmQgRFFVT1RFICgqIChhbmQgKG5vdC1mb2xsb3dlZC1ieSBEUVVPVEUpIENo YXIpKSBEUVVPVEUgU3BhY2luZykpKQorKGRlZmluZS1zZXhwLXBhcnNlciBDbGFzcyBhbGwK KyAgKGFuZCBPUEVOQlJBQ0tFVCAoKiAoYW5kIChub3QtZm9sbG93ZWQtYnkgQ0xPU0VCUkFD S0VUKSBSYW5nZSkpIENMT1NFQlJBQ0tFVCBTcGFjaW5nKSkKKyhkZWZpbmUtc2V4cC1wYXJz ZXIgUmFuZ2UgYWxsCisgIChvciAoYW5kIENoYXIgREFTSCBDaGFyKSBDaGFyKSkKKyhkZWZp bmUtc2V4cC1wYXJzZXIgQ2hhciBhbGwKKyAgKG9yIChhbmQgIlxcIiAob3IgIm4iICJyIiAi dCIgIiciICJcIiIgIlsiICJdIiAiXFwiKSkKKyAgICAgIChhbmQgIlxcIiAocmFuZ2UgI1ww ICNcNykgKHJhbmdlICNcMCAjXDcpIChyYW5nZSAjXDAgI1w3KSkKKyAgICAgIChhbmQgIlxc IiAocmFuZ2UgI1wwICNcNykgKD8gKHJhbmdlICNcMCAjXDcpKSkKKyAgICAgIChhbmQgKG5v dC1mb2xsb3dlZC1ieSAiXFwiKSBwZWctYW55KSkpCisoZGVmaW5lLXNleHAtcGFyc2VyIExF RlRBUlJPVyBib2R5CisgIChhbmQgKG9yICI8LS0iICI8LSIgIjwiKSBTcGFjaW5nKSkgOyBO T1RFOiA8LS0gYW5kIDwgYXJlIGV4dGVuc2lvbnMKKyhkZWZpbmUtc2V4cC1wYXJzZXIgU0xB U0ggbm9uZQorICAoYW5kICIvIiBTcGFjaW5nKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgQU5E IGFsbAorICAoYW5kICImIiBTcGFjaW5nKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgTk9UIGFs bAorICAoYW5kICIhIiBTcGFjaW5nKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgUVVFU1RJT04g YWxsCisgIChhbmQgIj8iIFNwYWNpbmcpKQorKGRlZmluZS1zZXhwLXBhcnNlciBTVEFSIGFs bAorICAoYW5kICIqIiBTcGFjaW5nKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgUExVUyBhbGwK KyAgKGFuZCAiKyIgU3BhY2luZykpCisoZGVmaW5lLXNleHAtcGFyc2VyIE9QRU4gbm9uZQor ICAoYW5kICIoIiBTcGFjaW5nKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgQ0xPU0Ugbm9uZQor ICAoYW5kICIpIiBTcGFjaW5nKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgRE9UIGFsbAorICAo YW5kICIuIiBTcGFjaW5nKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgU1FVT1RFIG5vbmUgIici KQorKGRlZmluZS1zZXhwLXBhcnNlciBEUVVPVEUgbm9uZSAiXCIiKQorKGRlZmluZS1zZXhw LXBhcnNlciBPUEVOQlJBQ0tFVCBub25lICJbIikKKyhkZWZpbmUtc2V4cC1wYXJzZXIgQ0xP U0VCUkFDS0VUIG5vbmUgIl0iKQorKGRlZmluZS1zZXhwLXBhcnNlciBEQVNIIG5vbmUgIi0i KQorKGRlZmluZS1zZXhwLXBhcnNlciBTcGFjaW5nIG5vbmUKKyAgKCogKG9yIFNwYWNlIENv bW1lbnQpKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgQ29tbWVudCBub25lCisgIChhbmQgIiMi ICgqIChhbmQgKG5vdC1mb2xsb3dlZC1ieSBFbmRPZkxpbmUpIHBlZy1hbnkpKSBFbmRPZkxp bmUpKQorKGRlZmluZS1zZXhwLXBhcnNlciBTcGFjZSBub25lCisgIChvciAiICIgIlx0IiBF bmRPZkxpbmUpKQorKGRlZmluZS1zZXhwLXBhcnNlciBFbmRPZkxpbmUgbm9uZQorICAob3Ig IlxyXG4iICJcbiIgIlxyIikpCisoZGVmaW5lLXNleHAtcGFyc2VyIEVuZE9mRmlsZSBub25l CisgIChub3QtZm9sbG93ZWQtYnkgcGVnLWFueSkpCisKIAogOzs7Ozs7Ozs7Ozs7Ozs7Ozs7 Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7 Ozs7Ozs7OzsKIDs7Ozs7IFBBUlNFIFNUUklORyBQRUdTCkBAIC0xMDEsNyArMTg2LDcgQEAg UkIgPCAnXScKIDs7IHdpbGwgZGVmaW5lIGFsbCBvZiB0aGUgbm9udGVybWluYWxzIGluIHRo ZSBncmFtbWFyIHdpdGggZXF1aXZhbGVudAogOzsgUEVHIHMtZXhwcmVzc2lvbnMuCiAoZGVm aW5lIChwZWctcGFyc2VyIHN0ciBmb3Itc3ludGF4KQotICAobGV0ICgocGFyc2VkIChtYXRj aC1wYXR0ZXJuIHBlZy1ncmFtbWFyIHN0cikpKQorICAobGV0ICgocGFyc2VkIChtYXRjaC1w YXR0ZXJuIEdyYW1tYXIgc3RyKSkpCiAgICAgKGlmIChub3QgcGFyc2VkKQogICAgICAgICAo YmVnaW4KICAgICAgICAgICA7OyAoZGlzcGxheSAiSW52YWxpZCBQRUcgZ3JhbW1hciFcbiIp CkBAIC0xMTAsMTEgKzE5NSwxNTQgQEAgUkIgPCAnXScKICAgICAgICAgICAoY29uZAogICAg ICAgICAgICAoKG9yIChub3QgKGxpc3Q/IGxzdCkpIChudWxsPyBsc3QpKQogICAgICAgICAg ICAgbHN0KQotICAgICAgICAgICAoKGVxPyAoY2FyIGxzdCkgJ3BlZy1ncmFtbWFyKQotICAg ICAgICAgICAgI2AoYmVnaW4KLSAgICAgICAgICAgICAgICAjLEAobWFwIChsYW1iZGEgKHgp IChwZWctbm9udGVybS0+ZGVmbiB4IGZvci1zeW50YXgpKQotICAgICAgICAgICAgICAgICAg ICAgICAgKGNvbnRleHQtZmxhdHRlbiAobGFtYmRhIChsc3QpICg8PSAoZGVwdGggbHN0KSAy KSkKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKGNkciBsc3Qp KSkpKSkpKSkpCisgICAgICAgICAgICgoZXE/IChjYXIgbHN0KSAnR3JhbW1hcikKKyAgICAg ICAgICAgIChHcmFtbWFyLT5kZWZuIGxzdCBmb3Itc3ludGF4KSkpKSkpKQorCis7OyAoR3Jh bW1hciAoRGVmaW5pdGlvbiAuLi4pIChEZWZpbml0aW9uIC4uLikpCisoZGVmaW5lIChHcmFt bWFyLT5kZWZuIGxzdCBmb3Itc3ludGF4KQorICAjYChiZWdpbgorICAgICAgIyxAKG1hcCAo bGFtYmRhICh4KSAoRGVmaW5pdGlvbi0+ZGVmbiB4IGZvci1zeW50YXgpKQorICAgICAgICAg ICAgICAoY29udGV4dC1mbGF0dGVuIChsYW1iZGEgKGxzdCkgKDw9IChkZXB0aCBsc3QpIDEp KQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChjZHIgbHN0KSkpKSkKKworOzsg KERlZmluaXRpb24gKElkZW50aWZpZXIgIlNvbWV0aGluZyIpICI8LSIgKEV4cHJlc3Npb24g Li4uKSkKKzs7ICBgLT4gKGRlZmluZS1wZWctcGF0dGVybiBTb21ldGhpbmcgJ2FsbCAuLi4p CisoZGVmaW5lIChEZWZpbml0aW9uLT5kZWZuIGxzdCBmb3Itc3ludGF4KQorICAobWF0Y2gg bHN0CisgICAgKCgnRGVmaW5pdGlvbiAoJ0lkZW50aWZpZXIgaWRlbnRpZmllcikgZ3JhYmJl ciBleHByZXNzaW9uKQorICAgICAjYChkZWZpbmUtcGVnLXBhdHRlcm4KKyAgICAgICAgICMs KGRhdHVtLT5zeW50YXggZm9yLXN5bnRheCAoc3RyaW5nLT5zeW1ib2wgaWRlbnRpZmllcikp CisgICAgICAgICAjLChtYXRjaCBncmFiYmVyCisgICAgICAgICAgICAgICAgICAoIjwtLSIg KGRhdHVtLT5zeW50YXggZm9yLXN5bnRheCAnYWxsKSkKKyAgICAgICAgICAgICAgICAgICgi PC0iICAoZGF0dW0tPnN5bnRheCBmb3Itc3ludGF4ICdib2R5KSkKKyAgICAgICAgICAgICAg ICAgICgiPCIgICAoZGF0dW0tPnN5bnRheCBmb3Itc3ludGF4ICdub25lKSkpCisgICAgICAg ICAjLChjb21wcmVzc29yCisgICAgICAgICAgICAgKEV4cHJlc3Npb24tPmRlZm4gZXhwcmVz c2lvbiBmb3Itc3ludGF4KQorICAgICAgICAgICAgIGZvci1zeW50YXgpKSkpKQorCis7OyAo RXhwcmVzc2lvbiBYKQorOzsgIGAtPiAob3IgWCkKKzs7IChFeHByZXNzaW9uIFggWSkKKzs7 ICBgLT4gKG9yIFggWSkKKzs7IChFeHByZXNzaW9uIFggKFkgWiAuLi4pKQorOzsgIGAtPiAo b3IgWCBZIFogLi4uKQorKGRlZmluZSAoRXhwcmVzc2lvbi0+ZGVmbiBsc3QgZm9yLXN5bnRh eCkKKyAgKG1hdGNoIGxzdAorICAgICgoJ0V4cHJlc3Npb24gc2VxIC4uLikKKyAgICAgI2Ao b3IgIyxAKG1hcCAobGFtYmRhICh4KSAoU2VxdWVuY2UtPmRlZm4geCBmb3Itc3ludGF4KSkK KyAgICAgICAgICAgICAgICAgICAoa2V5d29yZC1mbGF0dGVuICcoU2VxdWVuY2UpIHNlcSkp KSkpKQorCis7OyAoU2VxdWVuY2UgWCkKKzs7ICBgLT4gKGFuZCBYKQorOzsgKFNlcXVlbmNl IFggWSkKKzs7ICBgLT4gKGFuZCBYIFkpCis7OyAoU2VxdWVuY2UgWCAoWSBaIC4uLikpCis7 OyAgYC0+IChhbmQgWCBZIFogLi4uKQorKGRlZmluZSAoU2VxdWVuY2UtPmRlZm4gbHN0IGZv ci1zeW50YXgpCisgIChtYXRjaCBsc3QKKyAgICAoKCdTZXF1ZW5jZSBwcmUgLi4uKQorICAg ICAjYChhbmQgIyxAKG1hcCAobGFtYmRhICh4KSAoUHJlZml4LT5kZWZuIHggZm9yLXN5bnRh eCkpCisgICAgICAgICAgICAgICAgICAgIChrZXl3b3JkLWZsYXR0ZW4gJyhQcmVmaXgpIHBy ZSkpKSkpKQorCis7OyAoUHJlZml4IChTdWZmaXggLi4uKSkKKzs7ICBgLT4gKC4uLikKKzs7 IChQcmVmaXggKE5PVCAiISIpIChTdWZmaXggLi4uKSkKKzs7ICBgLT4gKG5vdC1mb2xsb3dl ZC1ieSAuLi4pCis7OyAoUHJlZml4IChBTkQgIiYiKSAoU3VmZml4IC4uLikpCis7OyAgYC0+ IChmb2xsb3dlZC1ieSAuLi4pCisoZGVmaW5lIChQcmVmaXgtPmRlZm4gbHN0IGZvci1zeW50 YXgpCisgIChtYXRjaCBsc3QKKyAgICAoKCdQcmVmaXggKCdBTkQgXykgc3UpICNgKGZvbGxv d2VkLWJ5ICAgICAjLChTdWZmaXgtPmRlZm4gc3UgZm9yLXN5bnRheCkpKQorICAgICgoJ1By ZWZpeCAoJ05PVCBfKSBzdSkgI2Aobm90LWZvbGxvd2VkLWJ5ICMsKFN1ZmZpeC0+ZGVmbiBz dSBmb3Itc3ludGF4KSkpCisgICAgKCgnUHJlZml4IHN1ZmZpeCkgKFN1ZmZpeC0+ZGVmbiBz dWZmaXggZm9yLXN5bnRheCkpKSkKKworOzsgKFN1ZmZpeCAoUHJpbWFyeSAuLi4pKQorOzsg IGAtPiAoLi4uKQorOzsgKFN1ZmZpeCAoUHJpbWFyeSAuLi4pIChTVEFSICIqIikpCis7OyAg YC0+ICgqIC4uLikKKzs7IChTdWZmaXggKFByaW1hcnkgLi4uKSAoUVVFU1RJT04gIj8iKSkK Kzs7ICBgLT4gKD8gLi4uKQorOzsgKFN1ZmZpeCAoUHJpbWFyeSAuLi4pIChQTFVTICIrIikp Cis7OyAgYC0+ICgrIC4uLikKKyhkZWZpbmUgKFN1ZmZpeC0+ZGVmbiBsc3QgZm9yLXN5bnRh eCkKKyAgKG1hdGNoIGxzdAorICAgICgoJ1N1ZmZpeCBwcmltKSAgICAgICAgICAgICAgIChQ cmltYXJ5LT5kZWZuIHByaW0gZm9yLXN5bnRheCkpCisgICAgKCgnU3VmZml4IHByaW0gKCdT VEFSICAgICBfKSkgI2AoKiAjLChQcmltYXJ5LT5kZWZuIHByaW0gZm9yLXN5bnRheCkpKQor ICAgICgoJ1N1ZmZpeCBwcmltICgnUVVFU1RJT04gXykpICNgKD8gIywoUHJpbWFyeS0+ZGVm biBwcmltIGZvci1zeW50YXgpKSkKKyAgICAoKCdTdWZmaXggcHJpbSAoJ1BMVVMgICAgIF8p KSAjYCgrICMsKFByaW1hcnktPmRlZm4gcHJpbSBmb3Itc3ludGF4KSkpKSkKKworCisoZGVm aW5lIChQcmltYXJ5LT5kZWZuIGxzdCBmb3Itc3ludGF4KQorICAobGV0ICgodmFsdWUgKHNl Y29uZCBsc3QpKSkKKyAgICAobWF0Y2ggKGNhciB2YWx1ZSkKKyAgICAgICgnRE9UICAgICAg ICAjJ3BlZy1hbnkpCisgICAgICAoJ0lkZW50aWZpZXIgKElkZW50aWZpZXItPmRlZm4gdmFs dWUgZm9yLXN5bnRheCkpCisgICAgICAoJ0V4cHJlc3Npb24gKEV4cHJlc3Npb24tPmRlZm4g dmFsdWUgZm9yLXN5bnRheCkpCisgICAgICAoJ0xpdGVyYWwgICAgKExpdGVyYWwtPmRlZm4g dmFsdWUgZm9yLXN5bnRheCkpCisgICAgICAoJ0NsYXNzICAgICAgKENsYXNzLT5kZWZuIHZh bHVlIGZvci1zeW50YXgpKSkpKQorCis7OyAoSWRlbnRpZmllciAiaGVsbG8iKQorOzsgIGAt PiBoZWxsbworKGRlZmluZSAoSWRlbnRpZmllci0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKKyAg KGRhdHVtLT5zeW50YXggZm9yLXN5bnRheCAoc3RyaW5nLT5zeW1ib2wgKHNlY29uZCBsc3Qp KSkpCisKKzs7IChMaXRlcmFsIChDaGFyICJhIikgKENoYXIgImIiKSAoQ2hhciAiYyIpKQor OzsgIGAtPiAiYWJjIgorKGRlZmluZSAoTGl0ZXJhbC0+ZGVmbiBsc3QgZm9yLXN5bnRheCkK KyAgKGFwcGx5IHN0cmluZyAobWFwIChsYW1iZGEgKHgpIChDaGFyLT5kZWZuIHggZm9yLXN5 bnRheCkpIChjZHIgbHN0KSkpKQorCis7OyBUT0RPOiBlbXB0eSBDbGFzcyBjYW4gaGFwcGVu OiBgW11gLCBidXQgd2hhdCBkb2VzIGl0IHJlcHJlc2VudD8KKzs7IChDbGFzcyAuLi4pCis7 OyAgYC0+IChvciAuLi4pCisoZGVmaW5lIChDbGFzcy0+ZGVmbiBsc3QgZm9yLXN5bnRheCkK KyAgI2Aob3IgIyxAKG1hcCAobGFtYmRhICh4KSAoUmFuZ2UtPmRlZm4geCBmb3Itc3ludGF4 KSkKKyAgICAgICAgICAgICAgICAoY2RyIGxzdCkpKSkKKworOzsgRm9yIG9uZSBjaGFyYWN0 ZXI6Cis7OyAoUmFuZ2UgKENoYXIgImEiKSkKKzs7ICBgLT4gImEiCis7OyBPciBmb3IgYSBy YW5nZToKKzs7IChSYW5nZSAoQ2hhciAiYSIpIChDaGFyICJiIikpCis7OyAgYC0+IChyYW5n ZSAjXGEgI1xiKQorKGRlZmluZSAoUmFuZ2UtPmRlZm4gbHN0IGZvci1zeW50YXgpCisgICht YXRjaCBsc3QKKyAgICAoKCdSYW5nZSBjaCkKKyAgICAgKHN0cmluZyAoQ2hhci0+ZGVmbiBj aCBmb3Itc3ludGF4KSkpCisgICAgKCgnUmFuZ2UgcmFuZ2UtYmVnaW5uaW5nIHJhbmdlLWVu ZCkKKyAgICAgI2AocmFuZ2UKKyAgICAgICAgICMsKENoYXItPmRlZm4gcmFuZ2UtYmVnaW5u aW5nIGZvci1zeW50YXgpCisgICAgICAgICAjLChDaGFyLT5kZWZuIHJhbmdlLWVuZCAgICAg ICBmb3Itc3ludGF4KSkpKSkKKworOzsgKENoYXIgImEiKQorOzsgIGAtPiAjXGEKKzs7IChD aGFyICJcXG4iKQorOzsgIGAtPiAjXG5ld2xpbmUKKzs7IChDaGFyICJcXDEzNSIpCis7OyAg YC0+ICNcXQorKGRlZmluZSAoQ2hhci0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKKyAgKGxldCog KChjaGFyc3RyIChzZWNvbmQgbHN0KSkKKyAgICAgICAgIChmaXJzdCAgIChzdHJpbmctcmVm IGNoYXJzdHIgMCkpKQorICAgIChjb25kCisgICAgICAoKD0gMSAoc3RyaW5nLWxlbmd0aCBj aGFyc3RyKSkgZmlyc3QpCisgICAgICAoKGNoYXItbnVtZXJpYz8gKHN0cmluZy1yZWYgY2hh cnN0ciAxKSkKKyAgICAgICAoaW50ZWdlci0+Y2hhcgorICAgICAgICAgKHJlZHVjZSArIDAK KyAgICAgICAgICAgICAgICAgKG1hcAorICAgICAgICAgICAgICAgICAgIChsYW1iZGEgKHgg eSkKKyAgICAgICAgICAgICAgICAgICAgICgqICgtIChjaGFyLT5pbnRlZ2VyIHgpIChjaGFy LT5pbnRlZ2VyICNcMCkpIHkpKQorICAgICAgICAgICAgICAgICAgIChyZXZlcnNlIChzdHJp bmctPmxpc3QgY2hhcnN0ciAxKSkKKyAgICAgICAgICAgICAgICAgICAnKDEgOCA2NCkpKSkp CisgICAgICAoZWxzZQorICAgICAgICAoY2FzZSAoc3RyaW5nLXJlZiBjaGFyc3RyIDEpCisg ICAgICAgICAgKCgjXG4pICNcbmV3bGluZSkKKyAgICAgICAgICAoKCNccikgI1xyZXR1cm4p CisgICAgICAgICAgKCgjXHQpICNcdGFiKQorICAgICAgICAgICgoI1wnKSAjXCcpCisgICAg ICAgICAgKCgjXF0pICNcXSkKKyAgICAgICAgICAoKCNcXCkgI1xcKQorICAgICAgICAgICgo I1xbKSAjXFspKSkpKSkKKworKGRlZmluZSBwZWctZ3JhbW1hciBHcmFtbWFyKQogCiA7OyBN YWNybyB3cmFwcGVyIGZvciBQRUctUEFSU0VSLiAgUGFyc2VzIFBFRyBncmFtbWFycyBleHBy ZXNzZWQgYXMgc3RyaW5ncyBhbmQKIDs7IGRlZmluZXMgYWxsIHRoZSBhcHByb3ByaWF0ZSBu b250ZXJtaW5hbHMuCkBAIC0xMjQsMTE5ICszNTIsNiBAQCBSQiA8ICddJwogICAgICAgKChf IHN0cikKICAgICAgICAocGVnLXBhcnNlciAoc3ludGF4LT5kYXR1bSAjJ3N0cikgeCkpKSkp CiAKLTs7IGxzdCBoYXMgZm9ybWF0IChub250ZXJtIGdyYWJiZXIgcGF0dGVybiksIHdoZXJl Ci07OyAgIG5vbnRlcm0gaXMgYSBzeW1ib2wgKHRoZSBuYW1lIG9mIHRoZSBub250ZXJtaW5h bCksCi07OyAgIGdyYWJiZXIgaXMgYSBzdHJpbmcgKGVpdGhlciAiPCIsICI8LSIgb3IgIjwt LSIpLCBhbmQKLTs7ICAgcGF0dGVybiBpcyB0aGUgcGFyc2Ugb2YgYSBQRUcgcGF0dGVybiBl eHByZXNzZWQgYXMgYXMgc3RyaW5nLgotKGRlZmluZSAocGVnLW5vbnRlcm0tPmRlZm4gbHN0 IGZvci1zeW50YXgpCi0gIChsZXQqICgobm9udGVybSAoY2FyIGxzdCkpCi0gICAgICAgICAo Z3JhYmJlciAoY2FkciBsc3QpKQotICAgICAgICAgKHBhdHRlcm4gKGNhZGRyIGxzdCkpCi0g ICAgICAgICAobm9udGVybS1uYW1lIChkYXR1bS0+c3ludGF4IGZvci1zeW50YXgKLSAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKHN0cmluZy0+c3ltYm9sIChjYWRy IG5vbnRlcm0pKSkpKQotICAgICNgKGRlZmluZS1wZWctcGF0dGVybiAjLG5vbnRlcm0tbmFt ZQotICAgICAgICMsKGNvbmQKLSAgICAgICAgICAoKHN0cmluZz0/IGdyYWJiZXIgIjwtLSIp IChkYXR1bS0+c3ludGF4IGZvci1zeW50YXggJ2FsbCkpCi0gICAgICAgICAgKChzdHJpbmc9 PyBncmFiYmVyICI8LSIpIChkYXR1bS0+c3ludGF4IGZvci1zeW50YXggJ2JvZHkpKQotICAg ICAgICAgIChlbHNlIChkYXR1bS0+c3ludGF4IGZvci1zeW50YXggJ25vbmUpKSkKLSAgICAg ICAjLChjb21wcmVzc29yIChwZWctcGF0dGVybi0+ZGVmbiBwYXR0ZXJuIGZvci1zeW50YXgp IGZvci1zeW50YXgpKSkpCi0KLTs7IGxzdCBoYXMgZm9ybWF0ICgncGVnLXBhdHRlcm4gLi4u KS4KLTs7IEFmdGVyIHRoZSBjb250ZXh0LWZsYXR0ZW4sIChjZHIgbHN0KSBoYXMgZm9ybWF0 Ci07OyAgICgoJ3BlZy1hbHRlcm5hdGl2ZSAuLi4pIC4uLiksIHdoZXJlIHRoZSBvdXRlciBs aXN0IGlzIGEgY29sbGVjdGlvbgotOzsgICBvZiBlbGVtZW50cyBmcm9tIGEgJy8nIGFsdGVy bmF0aXZlLgotKGRlZmluZSAocGVnLXBhdHRlcm4tPmRlZm4gbHN0IGZvci1zeW50YXgpCi0g ICNgKG9yICMsQChtYXAgKGxhbWJkYSAoeCkgKHBlZy1hbHRlcm5hdGl2ZS0+ZGVmbiB4IGZv ci1zeW50YXgpKQotICAgICAgICAgICAgICAgIChjb250ZXh0LWZsYXR0ZW4gKGxhbWJkYSAo eCkgKGVxPyAoY2FyIHgpICdwZWctYWx0ZXJuYXRpdmUpKQotICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgKGNkciBsc3QpKSkpKQotCi07OyBsc3QgaGFzIGZvcm1hdCAoJ3Bl Zy1hbHRlcm5hdGl2ZSAuLi4pLgotOzsgQWZ0ZXIgdGhlIGNvbnRleHQtZmxhdHRlbiwgKGNk ciBsc3QpIGhhcyB0aGUgZm9ybWF0Ci07OyAgIChpdGVtIC4uLiksIHdoZXJlIGVhY2ggaXRl bSBoYXMgZm9ybWF0IGVpdGhlciAoIiEiIC4uLiksICgiJiIgLi4uKSwKLTs7ICAgb3IgKCdw ZWctc3VmZml4IC4uLikuCi0oZGVmaW5lIChwZWctYWx0ZXJuYXRpdmUtPmRlZm4gbHN0IGZv ci1zeW50YXgpCi0gICNgKGFuZCAjLEAobWFwIChsYW1iZGEgKHgpIChwZWctYm9keS0+ZGVm biB4IGZvci1zeW50YXgpKQotICAgICAgICAgICAgICAgICAoY29udGV4dC1mbGF0dGVuIChs YW1iZGEgKHgpIChvciAoc3RyaW5nPyAoY2FyIHgpKQotICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgKGVxPyAoY2FyIHgpICdwZWctc3VmZml4KSkpCi0g ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKGNkciBsc3QpKSkpKQotCi07OyBs c3QgaGFzIHRoZSBmb3JtYXQgZWl0aGVyCi07OyAgICgiISIgKCdwZWctc3VmZml4IC4uLikp LCAoIiYiICgncGVnLXN1ZmZpeCAuLi4pKSwgb3IKLTs7ICAgICAoJ3BlZy1zdWZmaXggLi4u KS4KLShkZWZpbmUgKHBlZy1ib2R5LT5kZWZuIGxzdCBmb3Itc3ludGF4KQotICAgIChjb25k Ci0gICAgICAoKGVxdWFsPyAoY2FyIGxzdCkgIiYiKQotICAgICAgICNgKGZvbGxvd2VkLWJ5 ICMsKHBlZy1zdWZmaXgtPmRlZm4gKGNhZHIgbHN0KSBmb3Itc3ludGF4KSkpCi0gICAgICAo KGVxdWFsPyAoY2FyIGxzdCkgIiEiKQotICAgICAgICNgKG5vdC1mb2xsb3dlZC1ieSAjLChw ZWctc3VmZml4LT5kZWZuIChjYWRyIGxzdCkgZm9yLXN5bnRheCkpKQotICAgICAgKChlcT8g KGNhciBsc3QpICdwZWctc3VmZml4KQotICAgICAgIChwZWctc3VmZml4LT5kZWZuIGxzdCBm b3Itc3ludGF4KSkKLSAgICAgIChlbHNlIGAocGVnLXBhcnNlLWJvZHktZmFpbCAsbHN0KSkp KQotCi07OyBsc3QgaGFzIGZvcm1hdCAoJ3BlZy1zdWZmaXggPHBlZy1wcmltYXJ5PiAoPyAo LyAiKiIgIj8iICIrIikpKQotKGRlZmluZSAocGVnLXN1ZmZpeC0+ZGVmbiBsc3QgZm9yLXN5 bnRheCkKLSAgKGxldCAoKGlubmVyLWRlZm4gKHBlZy1wcmltYXJ5LT5kZWZuIChjYWRyIGxz dCkgZm9yLXN5bnRheCkpKQotICAgIChjb25kCi0gICAgICAoKG51bGw/IChjZGRyIGxzdCkp Ci0gICAgICAgaW5uZXItZGVmbikKLSAgICAgICgoZXF1YWw/IChjYWRkciBsc3QpICIqIikK LSAgICAgICAjYCgqICMsaW5uZXItZGVmbikpCi0gICAgICAoKGVxdWFsPyAoY2FkZHIgbHN0 KSAiPyIpCi0gICAgICAgI2AoPyAjLGlubmVyLWRlZm4pKQotICAgICAgKChlcXVhbD8gKGNh ZGRyIGxzdCkgIisiKQotICAgICAgICNgKCsgIyxpbm5lci1kZWZuKSkpKSkKLQotOzsgUGFy c2UgYSBwcmltYXJ5LgotKGRlZmluZSAocGVnLXByaW1hcnktPmRlZm4gbHN0IGZvci1zeW50 YXgpCi0gIChsZXQgKChlbCAoY2FkciBsc3QpKSkKLSAgKGNvbmQKLSAgICgobGlzdD8gZWwp Ci0gICAgKGNvbmQKLSAgICAgKChlcT8gKGNhciBlbCkgJ3BlZy1saXRlcmFsKQotICAgICAg KHBlZy1saXRlcmFsLT5kZWZuIGVsIGZvci1zeW50YXgpKQotICAgICAoKGVxPyAoY2FyIGVs KSAncGVnLWNoYXJjbGFzcykKLSAgICAgIChwZWctY2hhcmNsYXNzLT5kZWZuIGVsIGZvci1z eW50YXgpKQotICAgICAoKGVxPyAoY2FyIGVsKSAncGVnLW5vbnRlcm1pbmFsKQotICAgICAg KGRhdHVtLT5zeW50YXggZm9yLXN5bnRheCAoc3RyaW5nLT5zeW1ib2wgKGNhZHIgZWwpKSkp KSkKLSAgICgoc3RyaW5nPyBlbCkKLSAgICAoY29uZAotICAgICAoKGVxdWFsPyBlbCAiKCIp Ci0gICAgICAocGVnLXBhdHRlcm4tPmRlZm4gKGNhZGRyIGxzdCkgZm9yLXN5bnRheCkpCi0g ICAgICgoZXF1YWw/IGVsICIuIikKLSAgICAgIChkYXR1bS0+c3ludGF4IGZvci1zeW50YXgg J3BlZy1hbnkpKQotICAgICAoZWxzZSAoZGF0dW0tPnN5bnRheCBmb3Itc3ludGF4Ci0gICAg ICAgICAgICAgICAgICAgICAgICAgIGAocGVnLXBhcnNlLWFueSB1bmtub3duLXN0cmluZyAs bHN0KSkpKSkKLSAgIChlbHNlIChkYXR1bS0+c3ludGF4IGZvci1zeW50YXgKLSAgICAgICAg ICAgICAgICAgICAgICAgIGAocGVnLXBhcnNlLWFueSB1bmtub3duLWVsICxsc3QpKSkpKSkK LQotOzsgVHJpbXMgY2hhcmFjdGVycyBvZmYgdGhlIGZyb250IGFuZCBlbmQgb2YgU1RSLgot OzsgKHRyaW0tMWNoYXJzICInYWInIikgLT4gImFiIgotKGRlZmluZSAodHJpbS0xY2hhcnMg c3RyKSAoc3Vic3RyaW5nIHN0ciAxICgtIChzdHJpbmctbGVuZ3RoIHN0cikgMSkpKQotCi07 OyBQYXJzZXMgYSBsaXRlcmFsLgotKGRlZmluZSAocGVnLWxpdGVyYWwtPmRlZm4gbHN0IGZv ci1zeW50YXgpCi0gIChkYXR1bS0+c3ludGF4IGZvci1zeW50YXggKHRyaW0tMWNoYXJzIChj YWRyIGxzdCkpKSkKLQotOzsgUGFyc2VzIGEgY2hhcmNsYXNzLgotKGRlZmluZSAocGVnLWNo YXJjbGFzcy0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKLSAgI2Aob3IKLSAgICAgIyxAKG1hcAot ICAgICAgICAgKGxhbWJkYSAoY2MpCi0gICAgICAgICAgIChjb25kCi0gICAgICAgICAgICAo KGVxPyAoY2FyIGNjKSAnY2hhcmNsYXNzLXJhbmdlKQotICAgICAgICAgICAgICNgKHJhbmdl ICMsKGRhdHVtLT5zeW50YXgKLSAgICAgICAgICAgICAgICAgICAgICAgICBmb3Itc3ludGF4 Ci0gICAgICAgICAgICAgICAgICAgICAgICAgKHN0cmluZy1yZWYgKGNhZHIgY2MpIDApKQot ICAgICAgICAgICAgICAgICAgICAgICMsKGRhdHVtLT5zeW50YXgKLSAgICAgICAgICAgICAg ICAgICAgICAgICBmb3Itc3ludGF4Ci0gICAgICAgICAgICAgICAgICAgICAgICAgKHN0cmlu Zy1yZWYgKGNhZHIgY2MpIDIpKSkpCi0gICAgICAgICAgICAoKGVxPyAoY2FyIGNjKSAnY2hh cmNsYXNzLXNpbmdsZSkKLSAgICAgICAgICAgICAoZGF0dW0tPnN5bnRheCBmb3Itc3ludGF4 IChjYWRyIGNjKSkpKSkKLSAgICAgICAgIChjb250ZXh0LWZsYXR0ZW4KLSAgICAgICAgICAo bGFtYmRhICh4KSAob3IgKGVxPyAoY2FyIHgpICdjaGFyY2xhc3MtcmFuZ2UpCi0gICAgICAg ICAgICAgICAgICAgICAgICAgIChlcT8gKGNhciB4KSAnY2hhcmNsYXNzLXNpbmdsZSkpKQot ICAgICAgICAgIChjZHIgbHN0KSkpKSkKLQogOzsgQ29tcHJlc3NlcyBhIGxpc3QgdG8gc2F2 ZSB0aGUgb3B0aW1pemVyIHdvcmsuCiA7OyBlLmcuIChvciAoYW5kIGEpKSAtPiBhCiAoZGVm aW5lIChjb21wcmVzc29yLWNvcmUgbHN0KQpAQCAtMjYzLDExICszNzgsMTAgQEAgUkIgPCAn XScKICAgICAgKGxldCAoKHN0cmluZyAoc3ludGF4LT5kYXR1bSAjJ3N0ci1zdHgpKSkKICAg ICAgICAoY29tcGlsZS1wZWctcGF0dGVybgogICAgICAgICAoY29tcHJlc3NvcgotICAgICAg ICAgKHBlZy1wYXR0ZXJuLT5kZWZuCi0gICAgICAgICAgKHBlZzp0cmVlIChtYXRjaC1wYXR0 ZXJuIHBlZy1wYXR0ZXJuIHN0cmluZykpICMnc3RyLXN0eCkKKyAgICAgICAgIChFeHByZXNz aW9uLT5kZWZuCisgICAgICAgICAgKHBlZzp0cmVlIChtYXRjaC1wYXR0ZXJuIEV4cHJlc3Np b24gc3RyaW5nKSkgIydzdHItc3R4KQogICAgICAgICAgIydzdHItc3R4KQogICAgICAgICAo aWYgKGVxPyBhY2N1bSAnYWxsKSAnYm9keSBhY2N1bSkpKSkKICAgICAgKGVsc2UgKGVycm9y ICJCYWQgZW1iZWRkZWQgUEVHIHN0cmluZyIgYXJncykpKSkKIAogKGFkZC1wZWctY29tcGls ZXIhICdwZWcgcGVnLXN0cmluZy1jb21waWxlKQotCmRpZmYgLS1naXQgYS90ZXN0LXN1aXRl L3Rlc3RzL3BlZy50ZXN0IGIvdGVzdC1zdWl0ZS90ZXN0cy9wZWcudGVzdAppbmRleCBmNTE2 NTcxZTguLjExMzZjMDNmMSAxMDA2NDQKLS0tIGEvdGVzdC1zdWl0ZS90ZXN0cy9wZWcudGVz dAorKysgYi90ZXN0LXN1aXRlL3Rlc3RzL3BlZy50ZXN0CkBAIC0yOCwxNyArMjgsMjUgQEAK IDs7IHRoZSBub250ZXJtaW5hbHMgZGVmaW5lZCBpbiB0aGUgUEVHIHBhcnNlciB3cml0dGVu IHdpdGgKIDs7IFMtZXhwcmVzc2lvbnMuCiAoZGVmaW5lIGdyYW1tYXItbWFwcGluZwotICAn KChncmFtbWFyIHBlZy1ncmFtbWFyKQotICAgIChwYXR0ZXJuIHBlZy1wYXR0ZXJuKQotICAg IChhbHRlcm5hdGl2ZSBwZWctYWx0ZXJuYXRpdmUpCi0gICAgKHN1ZmZpeCBwZWctc3VmZml4 KQotICAgIChwcmltYXJ5IHBlZy1wcmltYXJ5KQotICAgIChsaXRlcmFsIHBlZy1saXRlcmFs KQotICAgIChjaGFyY2xhc3MgcGVnLWNoYXJjbGFzcykKLSAgICAoQ0NyYW5nZSBjaGFyY2xh c3MtcmFuZ2UpCi0gICAgKENDc2luZ2xlIGNoYXJjbGFzcy1zaW5nbGUpCi0gICAgKG5vbnRl cm1pbmFsIHBlZy1ub250ZXJtaW5hbCkKLSAgICAoc3AgcGVnLXNwKSkpCisgICcoKEdyYW1t YXIgR3JhbW1hcikKKyAgICAoRGVmaW5pdGlvbiBEZWZpbml0aW9uKQorICAgIChFeHByZXNz aW9uIEV4cHJlc3Npb24pCisgICAgKFNlcXVlbmNlIFNlcXVlbmNlKQorICAgIChQcmVmaXgg UHJlZml4KQorICAgIChTdWZmaXggU3VmZml4KQorICAgIChQcmltYXJ5IFByaW1hcnkpCisg ICAgKElkZW50aWZpZXIgSWRlbnRpZmllcikKKyAgICAoTGl0ZXJhbCBMaXRlcmFsKQorICAg IChDbGFzcyBDbGFzcykKKyAgICAoUmFuZ2UgUmFuZ2UpCisgICAgKENoYXIgQ2hhcikKKyAg ICAoTEVGVEFSUk9XIExFRlRBUlJPVykKKyAgICAoQU5EIEFORCkKKyAgICAoTk9UIE5PVCkK KyAgICAoUVVFU1RJT04gUVVFU1RJT04pCisgICAgKFNUQVIgU1RBUikKKyAgICAoUExVUyBQ TFVTKQorICAgIChET1QgRE9UKSkpCiAKIDs7IFRyYW5zZm9ybXMgdGhlIG5vbnRlcm1pbmFs cyBkZWZpbmVkIGluIHRoZSBQRUcgcGFyc2VyIHdyaXR0ZW4gYXMgYSBQRUcgdG8gdGhlIG5v bnRlcm1pbmFscyBkZWZpbmVkIGluIHRoZSBQRUcgcGFyc2VyIHdyaXR0ZW4gd2l0aCBTLWV4 cHJlc3Npb25zLgogKGRlZmluZSAoZ3JhbW1hci10cmFuc2Zvcm0geCkKQEAgLTY5LDcgKzc3 LDcgQEAKICAgICAocGVnOnRyZWUgKG1hdGNoLXBhdHRlcm4gKEBAIChpY2UtOSBwZWcpIHBl Zy1ncmFtbWFyKSAoQEAgKGljZS05IHBlZykgcGVnLWFzLXBlZykpKQogICAgICh0cmVlLW1h cAogICAgICBncmFtbWFyLXRyYW5zZm9ybQotICAgICAocGVnOnRyZWUgKG1hdGNoLXBhdHRl cm4gZ3JhbW1hciAoQEAgKGljZS05IHBlZykgcGVnLWFzLXBlZykpKSkpKSkKKyAgICAgKHBl Zzp0cmVlIChtYXRjaC1wYXR0ZXJuIEdyYW1tYXIgKEBAIChpY2UtOSBwZWcpIHBlZy1hcy1w ZWcpKSkpKSkpCiAKIDs7IEEgZ3JhbW1hciBmb3IgcGFzY2FsLXN0eWxlIGNvbW1lbnRzIGZy b20gV2lraXBlZGlhLgogKGRlZmluZSBjb21tZW50LWdyYW1tYXIKLS0gCjIuNDYuMAoK --------------QKBL2uiBJnbd9YBTHqXA1fU1-- From debbugs-submit-bounces@debbugs.gnu.org Wed Oct 30 15:04:47 2024 Received: (at 73188) by debbugs.gnu.org; 30 Oct 2024 19:04:47 +0000 Received: from localhost ([127.0.0.1]:36871 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1t6Dzo-0005Ac-RS for submit@debbugs.gnu.org; Wed, 30 Oct 2024 15:04:47 -0400 Received: from dane.soverin.net ([185.233.34.21]:44857) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1t6Dzk-0005AJ-Jk for 73188@debbugs.gnu.org; Wed, 30 Oct 2024 15:04:43 -0400 Received: from smtp.soverin.net (unknown [10.10.4.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by dane.soverin.net (Postfix) with ESMTPS id 4XdxPJ17gRzHb; Wed, 30 Oct 2024 19:04:04 +0000 (UTC) Received: from smtp.soverin.net (smtp.soverin.net [10.10.4.100]) by soverin.net (Postfix) with ESMTPSA id 4XdxPH41h0zLX; Wed, 30 Oct 2024 19:04:03 +0000 (UTC) Authentication-Results: smtp.soverin.net; dkim=pass (2048-bit key; unprotected) header.d=elenq.tech header.i=@elenq.tech header.a=rsa-sha256 header.s=soverin1 header.b=XhkMwxK3; dkim-atps=neutral DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=elenq.tech; s=soverin1; t=1730315043; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type:autocrypt:autocrypt; bh=gADrNrX2cdhADZGzkLAqFpZLdETsF5SIvmWgRvhpdvQ=; b=XhkMwxK346OMPJvPJahMkFWWmemDF8NBLwG+1xstSZvMyR3WRKBPxxDCOop0zNxQlSxnMl 9FwYoNNRjQ8oGlqblcFqw/lHcPy/6LUbzyvO30HvGeo1ipmpAhlCr2XsZAcK3ljugVwLhu bJqfczeCLwCswP17KYFTAme+QlntWtxDi6I0HgeL17C+9zwausxiRTaxoAuRVXGPXScV+h AJaRCx9GvJHhS5OOwoq8+aeB5o6y1/ojoTBMZtynsBg/SwIAzmXs6fT4RqsJv5z+w59xmS lpjcRf4sYy+lG5r/QZVqVLQvcM5gHeRhoriQdkI/evrddrsRUwGf1bz0su43kg== Content-Type: multipart/mixed; boundary="------------Y2zdP01HIvyrhdt0oeLCmvOa" Message-ID: <0994541b-538d-4f03-bf13-78ef8917099f@elenq.tech> Date: Wed, 30 Oct 2024 20:04:02 +0100 MIME-Version: 1.0 Content-Language: en-US, es-ES, eu To: 73188@debbugs.gnu.org From: Ekaitz Zarraga Subject: PEG: Fix bugs and add complex PEG for testing Autocrypt: addr=ekaitz@elenq.tech; keydata= xsFNBGViSyIBEADY3g71uW/0CVaVm5/ObqTicQXXJRuh1uafIFiUUZoAp1V3V89b3LZ/m0cL 8YNHxTxsx8sKIMYTGlOvARAMiSpDvkmpf5pLn5T7+VvK90FOv/Pkp1tNNT+tvd0m/7C58+39 s7tN+XppbjVRtFuSXY0aFe8rpivZsKxv+tPUHUnQQszXvwgx0GQl8AX99IE+j75NJmBHFVg2 0geKa7QVymu669ix2+zU8vGoOKf5nIS0qG1m/vrtwR3ZuuyWX9/E/uP95ahX5ETWtjhTDbEm MEaRperwbczBewkdERJ34vRrverqKQA1xHXoPsx4NkLMocORFSSCJsveXcgWlU+pUIOYcKUA ARJjHhoWoUH4LZt5EOb7U17AaYMmATUXPCqq8G3jEXq6i0O1J1obCJGIRG02R9GiGp4zrVuv 2hmyoAmed4xYZAtf9WjcbwiunDkMGIxscdSlfEH/9dt7PGdEvkZ0dNSCTbp4ctMI4jAfobAL LReMSGx1CgPi01J61a/n/SgR66AiRJZCyC1u2V7AK1rBOAYzOU4UoePz+yF1I7crjZWAQVo6 DlmmXW+29l/lh2oK5jOuNEcvI6qi+tPCYxpDhUhZeYgqFU+/xgGlMj/XGvwuIFlpVg9ovFMg 6mxskOCVP9xNEp/qHiHqByYu5NRcITo/z/3BUimdXTT4KSq2cQARAQABzSJFa2FpdHogWmFy cmFnYSA8ZWthaXR6QGVsZW5xLnRlY2g+wsGOBBMBCAA4FiEEg/pnRVjAUpRlfkwZt5lM+Jly CyYFAmViSyICGwMFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQt5lM+JlyCybjZxAAy+YW 3Q22xKoMWJYw03qGCy87WPK+xGWDpKD6TJ77+/IEbldObyQRrKYTTGjQSy6WgaJ0txJMIqeK JyuWuR3bq+Vkh86Byntl25jknOJ+jY1zwPs6HnWFr+hS48FcQh/0D26h57Cqc+6nbKhJcva8 JsInbHTbWPz7wye+xhqY1LfdgVTbCyADESXdmBY30/vP4LzqW81atwYF6X7dN7ko/JvyPPdv VlcspmbP6zNihoApBHdMfJwYscyAsu6tTyL4hMG3zpraeU+S857vZN39gFagRng+uyZG7rfB dHHAFzT1LKOZ4dahavOfA0gS1RZTgtAGsvhUEBn9vKxlB4efZuKhwMtgQEskRFD6JIF1DYCj pLgn5x/y3oI6rn35R46VDhLfohcUWpvzplu6LBft8ZNr+UgoVYc6qBezyDlxk0FmhGI7DEoh gfUxljTALXjSdUGEw2mvp/Mcrz+ffemWpG4+Zq0UXR8sZaHpv+PqmFLFFSQCOCRTYbMKzZBn y03wym3y0tGtunDGm5pR7NEPqUO9QbZdKyTy4ftRkSfTpiPCF8+KKYDT8HimSrusmtTfR4R1 nBJ4lNBYgTdOyJYFbHdF0Jxo9r0t+K2e+6hX6bK79o6aC+/LtzkoYgjCWvAEopO0ras/XQYM S7/bCzeDIhXX5RqmMIp5XN+oBP2roZDOwU0EZWJLIgEQAMIgPDpJY9aOhFiFICx58XMM28An yUPdN39t0A8VkUbsvKXH6eNqUZj/Q3yNcZrknAT1vinv9FN/4uCUnsaqEKp+mRAYgzmNfeJk SWuMzmA04fcISIBz3sJUR0w/59tWi8QxlNn7IR6McAA3lHDXC+KYh9ZfhaOARfan1M6Ppy6g YltUQGSSPXU807inmQZh8GFTi8iUza7vGuBEnaNRGhmhR+blMwHSqVWN4gD81e8dSAEi3zNR sLoBXneHUqTcJMHvsT5cOk7cGMoVAWIffA2EKWfrgda57Qw+w+0OPqWEfKoXwnyt35Tl+Lxl 7MAaAG9R5760yhgkf3LmnBNP3m6StZ8Fv09Gdn5cGSbVnoofHDkg4PQDTD6aGz9af3SnGVg9 nb1Zm1XbqtnYwG9JvQhcjgWAHwrPLkHAcvKtfYWNe4wiirMjXMXxADY08g33SEchPJR2r4pg wttJS4kHUJ2IQUmSH/43RO5PkftWsCucYGeaG1aPr+GAkeKIS1M3OZGuqhd800mltpiH73eL XrUPF8fgngC+SGMrHXLfzuhaRxPNYUbsdF+wRkvjRSO4tCmSVpgfPsHu5emoZgix1iiTO7GF do7L6n1Ay3oF4Witoxc0Gcbu7ltYlZHGmDnsVTVALartsJV2muSXpWcjQiXyC0gUkIkUD/3P jtgVxK8xABEBAAHCwXYEGAEIACAWIQSD+mdFWMBSlGV+TBm3mUz4mXILJgUCZWJLIgIbDAAK CRC3mUz4mXILJrIaD/9CXGckwRCojuRzP0r6+8/RvNDc03CSe2W17WrSaoYgiRb+h5asI/AL yqw+QRgwXZpt0i9hNiDCe/baD62mufIyjKFjHoAWSYJuZ5VK3vWnro6GaxWULYt1+c4c4Lz2 d1nSK6j8F3CxYo7BFk6afOusjYfh+0HywThcYY+x+K5Z+4SdJejDLiL5AzJn2W5Gt/ViK5nI wl7uRQpayMc9zmI8ytUT2NJxovq1/fT9nB8VPwlbJTE9zvIqfqHh9o9Apx5o8yTaSCyGUyu9 8h/klqxFy4HAPJJu/3JkiMaCI45ZdCqRR1LIwhtmW2lb73r0rP/0S1cKi+ehA4oQvwiUw7zh XXw7mqzSAJ0SWT92Vy2G8Z8qqgwxwfQcdFZAyJAL1rgEPQljNT91Vgbc6DCUka2XW5BqyhEB eS0n1gK0hYXbM9FKegRsZxlmRAXa4KGXCwr4BNK6k+zkKPitezjbtcLgcKSHa8/HyHNkW7xH R+MN16x2elQPmQ2d0Ien1HgsK98+3prlUGwZIVCqa1ddSoW0llU3JzGsKrMAiYbWg/rOXFil RJbuhjflaLBVmfI8VlRQRocP+WEH0lsUWrtjVaGcBj1/YnIoT+zT6fPSXwPsrBvAWEjfl8HH e1F4cYb+ugPDwUTd1s2Uj2tF0/fhCHPy9sXyx/EIL3gqyBw9M2Rz9A== X-Spampanel-Class: ham X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 73188 Cc: =?UTF-8?Q?Ludovic_Court=C3=A8s?= X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) This is a multi-part message in MIME format. --------------Y2zdP01HIvyrhdt0oeLCmvOa Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 7bit Hi, I decided to improve the tests of the PEG module because I wasn't very confident about the [^...] functionality, and I found I had some minor bugs in the previous patch. I attach a new version of the previous commits with an extra one that adds an HTML parser and tests against it. That's what made me find some of the errors and missing bits. With the test I feel more confident about the changes. Thanks, Ekaitz --------------Y2zdP01HIvyrhdt0oeLCmvOa Content-Type: text/x-patch; charset=UTF-8; name="v5-0003-PEG-Add-a-complex-PEG-grammar-test.patch" Content-Disposition: attachment; filename="v5-0003-PEG-Add-a-complex-PEG-grammar-test.patch" Content-Transfer-Encoding: base64 RnJvbSBlNjgyNTQ0YTY4ZmYxZDllNDFmYjk1NDUzOTg4NGI3MTYzMTI0NTg5IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBFa2FpdHogWmFycmFnYSA8ZWthaXR6QGVsZW5xLnRl Y2g+CkRhdGU6IFdlZCwgMzAgT2N0IDIwMjQgMTk6NTI6MjggKzAxMDAKU3ViamVjdDogW1BB VENIIHY1IDMvM10gUEVHOiBBZGQgYSBjb21wbGV4IFBFRyBncmFtbWFyIHRlc3QKCkFkZCBh IGNvbXBsZXggUEVHIGdyYW1tYXIgZm9yIEhUTUwgcGFyc2luZyBhbmQgdGVzdCBhZ2FpbnN0 IGl0LgpUaGlzIHByb3Blcmx5IHRlc3RzIGZvciBjb21wbGV4IGNvbnN0cnVjdHMsIHNwZWNp YWxseSBgW14uLi5dYC4KCiogdGVzdC1zdWl0ZS90ZXN0cy9wZWcudGVzdCAoaHRtbC1ncmFt bWFyKTogTmV3IHZhcmlhYmxlLgooaHRtbC1leGFtcGxlKTogTmV3IHZhcmlhYmxlLgooUGFy c2luZyB3aXRoIGNvbXBsZXggZ3JhbW1hcnMpOiBOZXcgdGVzdC4KLS0tCiB0ZXN0LXN1aXRl L3Rlc3RzL3BlZy50ZXN0IHwgMTEzICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrCiAxIGZpbGUgY2hhbmdlZCwgMTEzIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQg YS90ZXN0LXN1aXRlL3Rlc3RzL3BlZy50ZXN0IGIvdGVzdC1zdWl0ZS90ZXN0cy9wZWcudGVz dAppbmRleCA1NTcwZmJmYTguLmQ4ZDA0NzI4OCAxMDA2NDQKLS0tIGEvdGVzdC1zdWl0ZS90 ZXN0cy9wZWcudGVzdAorKysgYi90ZXN0LXN1aXRlL3Rlc3RzL3BlZy50ZXN0CkBAIC0yODQs MyArMjg0LDExNiBAQCBudW1iZXIgPC0tIFswLTldKyIpCiAgICAiMSsxLzIqMysoMSsxKS8y IgogICAgKGVxdWFsPyAoZXEtcGFyc2UgIjErMS8yKjMrKDErMSkvMiIpCiAJICAgJygrICgr IDEgKCogKC8gMSAyKSAzKSkgKC8gKCsgMSAxKSAyKSkpKSkKKworCisoZGVmaW5lIGh0bWwt Z3JhbW1hcgorIgorIyBCYXNlZCBvbiBjb2RlIGZyb20gaHR0cHM6Ly9naXRodWIuY29tL0Zh bnRvbS1GYWN0b3J5L2FmSHRtbFBhcnNlcgorIyAyMDE0LTIwMjMgU3RldmUgRXlub24uIFRo aXMgY29kZSB3YXMgb3JpZ2luYWxseSByZWxlYXNlZCB1bmRlciB0aGUgZm9sbG93aW5nCisj IHRlcm1zOgorIworIyAgICAgIFBlcm1pc3Npb24gdG8gdXNlLCBjb3B5LCBtb2RpZnksIGFu ZC9vciBkaXN0cmlidXRlIHRoaXMgc29mdHdhcmUgZm9yIGFueQorIyAgICAgIHB1cnBvc2Ug d2l0aCBvciB3aXRob3V0IGZlZSBpcyBoZXJlYnkgZ3JhbnRlZCwgcHJvdmlkZWQgdGhhdCB0 aGUgYWJvdmUKKyMgICAgICBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24g bm90aWNlIGFwcGVhciBpbiBhbGwgY29waWVzLgorIworIyAgICAgIFRIRSBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBcIkFTIElTXCIgQU5EIFRIRSBBVVRIT1IgRElTQ0xBSU1TIEFMTAorIyAg ICAgIFdBUlJBTlRJRVMgV0lUSCBSRUdBUkQgVE8gVEhJUyBTT0ZUV0FSRSBJTkNMVURJTkcg QUxMIElNUExJRUQgV0FSUkFOVElFUworIyAgICAgIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQg RklUTkVTUy4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIEFVVEhPUiBCRSBMSUFCTEUKKyMgICAg ICBGT1IgQU5ZIFNQRUNJQUwsIERJUkVDVCwgSU5ESVJFQ1QsIE9SIENPTlNFUVVFTlRJQUwg REFNQUdFUyBPUiBBTlkKKyMgICAgICBEQU1BR0VTIFdIQVRTT0VWRVIgUkVTVUxUSU5HIEZS T00gTE9TUyBPRiBVU0UsIERBVEEgT1IgUFJPRklUUywgV0hFVEhFUgorIyAgICAgIElOIEFO IEFDVElPTiBPRiBDT05UUkFDVCwgTkVHTElHRU5DRSBPUiBPVEhFUiBUT1JUSU9VUyBBQ1RJ T04sIEFSSVNJTkcKKyMgICAgICBPVVQgT0YgT1IgSU4gQ09OTkVDVElPTiBXSVRIIFRIRSBV U0UgT1IgUEVSRk9STUFOQ0UgT0YgVEhJUyBTT0ZUV0FSRS4KKworIyBQRUcgUnVsZXMgZm9y IHBhcnNpbmcgd2VsbCBmb3JtZWQgSFRNTCA1IGRvY3VtZW50cworIyBodHRwczovL2h0bWwu c3BlYy53aGF0d2cub3JnL211bHRpcGFnZS9zeW50YXguaHRtbAorCitodG1sICAgICAgICA8 LS0gYm9tPyBibHVyYiogZG9jdHlwZT8gYmx1cmIqIHhtbFByb2xvZz8gYmx1cmIqIGVsZW0g Ymx1cmIqCitib20gICAgICAgICA8LS0gXCJcXHVGRUZGXCIKK3htbFByb2xvZyAgIDwtLSBc Ijw/eG1sXCIgKCFcIj8+XCIgLikrIFwiPz5cIgorCisjIC0tLS0gRG9jdHlwZSAtLS0tCisK K2RvY3R5cGUgICAgICAgICAgIDwtLSBcIjwhRE9DVFlQRVwiIFsgXFx0XFxuXFxmXFxyXSsg W2EtekEtWjAtOV0rIChkb2N0eXBlUHVibGljSWQgLyBkb2N0eXBlU3lzdGVtSWQpKiBbIFxc dFxcblxcZlxccl0qIFwiPlwiCitkb2N0eXBlUHVibGljSWQgICA8LS0gWyBcXHRcXG5cXGZc XHJdKyAgXCJQVUJMSUNcIiBbIFxcdFxcblxcZlxccl0rICAgKChcIlxcXCJcIiBbXlwiXSog XCJcXFwiXCIpIC8gKFwiJ1wiIFteJ10qIFwiJ1wiKSkKK2RvY3R5cGVTeXN0ZW1JZCAgIDwt LSBbIFxcdFxcblxcZlxccl0rIChcIlNZU1RFTVwiIFsgXFx0XFxuXFxmXFxyXSspPyAoKFwi XFxcIlwiIFteXCJdKiBcIlxcXCJcIikgLyAoXCInXCIgW14nXSogXCInXCIpKQorCisjIC0t LS0gRWxlbXMgLS0tLQorCitlbGVtICAgICAgICAgICAgICA8LS0gdm9pZEVsZW0gLyByYXdU ZXh0RWxlbSAvIGVzY1Jhd1RleHRFbGVtIC8gc2VsZkNsb3NpbmdFbGVtIC8gbm9ybWFsRWxl bQordm9pZEVsZW0gICAgICAgICAgPC0tIFwiPFwiICB2b2lkRWxlbU5hbWUgICAgICAgYXR0 cmlidXRlcyAgXCI+XCIKK3Jhd1RleHRFbGVtICAgICAgIDwtLSBcIjxcIiAgcmF3VGV4dEVs ZW1OYW1lICAgIGF0dHJpYnV0ZXMgIFwiPlwiIHJhd1RleHRDb250ZW50IGVuZEVsZW0KK2Vz Y1Jhd1RleHRFbGVtICAgIDwtLSBcIjxcIiAgZXNjUmF3VGV4dEVsZW1OYW1lIGF0dHJpYnV0 ZXMgIFwiPlwiIGVzY1Jhd1RleHRDb250ZW50IGVuZEVsZW0KK3NlbGZDbG9zaW5nRWxlbSAg IDwtLSBcIjxcIiAgZWxlbU5hbWUgICAgICAgICAgIGF0dHJpYnV0ZXMgXCIvPlwiCitub3Jt YWxFbGVtICAgICAgICA8LS0gXCI8XCIgIGVsZW1OYW1lICAgICAgICAgICBhdHRyaWJ1dGVz ICBcIj5cIiBub3JtYWxDb250ZW50PyBlbmRFbGVtPworZW5kRWxlbSAgICAgICAgICAgPC0t IFwiPC9cIiBlbGVtTmFtZSAgICAgICAgICAgICAgICAgICAgICAgXCI+XCIKKworZWxlbU5h bWUgICAgICAgICAgICA8LS0gW2EtekEtWl0gW15cXHRcXG5cXGYgLz5dKgordm9pZEVsZW1O YW1lICAgICAgICA8LS0gXCJhcmVhXCIgLyBcImJhc2VcIiAvIFwiYnJcIiAvIFwiY29sXCIg LyBcImVtYmVkXCIgLworICAgICAgICAgICAgICAgICAgICAgIFwiaHJcIiAvIFwiaW1nXCIg LyBcImlucHV0XCIgLyBcImtleWdlblwiIC8gXCJsaW5rXCIgLworICAgICAgICAgICAgICAg ICAgICAgIFwibWV0YVwiIC8gXCJwYXJhbVwiIC8gXCJzb3VyY2VcIiAvIFwidHJhY2tcIiAv IFwid2JyXCIKK3Jhd1RleHRFbGVtTmFtZSAgICAgPC0tIFwic2NyaXB0XCIgLyBcInN0eWxl XCIKK2VzY1Jhd1RleHRFbGVtTmFtZSAgPC0tIFwidGV4dGFyZWFcIiAvIFwidGl0bGVcIgor CityYXdUZXh0Q29udGVudCAgICAgIDwtLSAoIShcIjwvc2NyaXB0PlwiIC8gXCI8L3N0eWxl PlwiKSAuKSsKK2VzY1Jhd1RleHRDb250ZW50ICAgPC0tICgoIShcIjwvdGV4dGFyZWE+XCIg LyBcIjwvdGl0bGU+XCIgLyBcIiZcIikgLikrIC8gY2hhclJlZikqCitub3JtYWxDb250ZW50 ICAgICAgIDwtLSAhXCI8L1wiICgoW148Jl0rIC8gY2hhclJlZikgLyBjb21tZW50IC8gY2Rh dGEgLyBlbGVtKSoKKworIyAtLS0tIEF0dHJpYnV0ZXMgLS0tLQorCithdHRyaWJ1dGVzICAg ICAgICA8LS0gKCZbXi8+XSAoWyBcXHRdKyAvIGRvdWJsZVF1b3RlQXR0ciAvIHNpbmdsZVF1 b3RlQXR0ciAvIHVucXVvdGVkQXR0ciAvIGVtcHR5QXR0cikpKgorYXR0ck5hbWUgICAgICAg ICAgPC0tIFteIFxcdFxcblxcclxcZlwiJz4vPV0rCitlbXB0eUF0dHIgICAgICAgICA8LS0g YXR0ck5hbWUrCit1bnF1b3RlZEF0dHIgICAgICA8LS0gYXR0ck5hbWUgWyBcXHRdKiBcIj1c IiBbIFxcdF0qICAgICAgKGNoYXJSZWYgLyBbXiBcXHRcXG5cXHJcXGZcIic9PD5gJl0rKSsK K3NpbmdsZVF1b3RlQXR0ciAgIDwtLSBhdHRyTmFtZSBbIFxcdF0qIFwiPVwiIFsgXFx0XSog XCInXCIgIChjaGFyUmVmIC8gW14nJl0rKSogXCInXCIKK2RvdWJsZVF1b3RlQXR0ciAgIDwt LSBhdHRyTmFtZSBbIFxcdF0qIFwiPVwiIFsgXFx0XSogXCJcXFwiXCIgKGNoYXJSZWYgLyBb XlwiJl0rKSogXCJcXFwiXCIKKworIyAtLS0tIENoYXJhY3RlciBSZWZlcmVuY2VzIC0tLS0K KworY2hhclJlZiAgICAgICAgIDwtLSAmXCImXCIgKGRlY051bUNoYXJSZWYgLyBoZXhOdW1D aGFyUmVmIC8gbmFtZWRDaGFyUmVmIC8gYm9ya2VkUmVmKQorbmFtZWRDaGFyUmVmICAgIDwt LSBcIiZcIiAgIFteOz5dKyBcIjtcIgorZGVjTnVtQ2hhclJlZiAgIDwtLSBcIiYjXCIgIFsw LTldKyBcIjtcIgoraGV4TnVtQ2hhclJlZiAgIDwtLSBcIiYjeFwiIFthLWZBLUYwLTldKyBc IjtcIgorYm9ya2VkUmVmICAgICAgIDwtLSBcIiZcIiAgJlsgXFx0XQorCisjIC0tLS0gTWlz YyAtLS0tCisKK2NkYXRhICAgICAgIDwtLSBcIjwhW0NEQVRBW1wiICghXCJdXT5cIiAuKSsg XCJdXT5cIgorY29tbWVudCAgICAgPC0tIFwiPCEtLVwiICghXCItLVwiIC4pKyBcIi0tPlwi CitibHVyYiAgICAgICA8LS0gWyBcXHRcXG5cXGZcXHJdKyAvIGNvbW1lbnQiKQorCisoZGVm aW5lIGh0bWwtZXhhbXBsZSAiCis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cisg ICAgPHRpdGxlPkV4YW1wbGUgRG9tYWluPC90aXRsZT4KKyAgICA8bWV0YSBjaGFyc2V0PVwi dXRmLThcIiAvPgorICAgIDxtZXRhIGh0dHAtZXF1aXY9XCJDb250ZW50LXR5cGVcIiBjb250 ZW50PVwidGV4dC9odG1sOyBjaGFyc2V0PXV0Zi04XCIgLz4KKyAgICA8bWV0YSBuYW1lPVwi dmlld3BvcnRcIiBjb250ZW50PVwid2lkdGg9ZGV2aWNlLXdpZHRoLCBpbml0aWFsLXNjYWxl PTFcIiAvPgorICAgIDxzdHlsZSB0eXBlPVwidGV4dC9jc3NcIj4KKyAgICBib2R5IHsKKyAg ICAgICAgYmFja2dyb3VuZC1jb2xvcjogI2YwZjBmMjsKKyAgICAgICAgbWFyZ2luOiAwOwor ICAgICAgICBwYWRkaW5nOiAwOworICAgIH0KKyAgICA8L3N0eWxlPgorPC9oZWFkPgorCis8 Ym9keT4KKzxkaXY+CisgICAgPGgxPkV4YW1wbGUgRG9tYWluPC9oMT4KKyAgICA8cD5UaGlz IGRvbWFpbiBpcyBmb3IgdXNlIGluIGlsbHVzdHJhdGl2ZSBleGFtcGxlcyBpbiBkb2N1bWVu dHMuIFlvdSBtYXkKKyAgICB1c2UgdGhpcyBkb21haW4gaW4gbGl0ZXJhdHVyZSB3aXRob3V0 IHByaW9yIGNvb3JkaW5hdGlvbiBvciBhc2tpbmcgZm9yCisgICAgcGVybWlzc2lvbi48L3A+ IDxwPjxhIGhyZWY9XCJodHRwczovL3d3dy5pYW5hLm9yZy9kb21haW5zL2V4YW1wbGVcIj5N b3JlCisgICAgaW5mb3JtYXRpb24uLi48L2E+PC9wPgorPC9kaXY+Cis8L2JvZHk+Cis8L2h0 bWw+CisiKQorCisod2l0aC10ZXN0LXByZWZpeCAiUGFyc2luZyB3aXRoIGNvbXBsZXggZ3Jh bW1hcnMiCisgIChlZXZhbCBgKGRlZmluZS1wZWctc3RyaW5nLXBhdHRlcm5zICxodG1sLWdy YW1tYXIpKQorICAocGFzcy1pZgorICAgICJIVE1MIHBhcnNpbmciCisgICAgKGVxdWFsPwor ICAgICAgKHBlZzp0cmVlIChtYXRjaC1wYXR0ZXJuIGh0bWwgaHRtbC1leGFtcGxlKSkKKyAg ICAgICcoaHRtbCAoYmx1cmIgIlxuIikgKGRvY3R5cGUgIjwhRE9DVFlQRSBodG1sPiIpIChi bHVyYiAiXG4iKSAoZWxlbSAobm9ybWFsRWxlbSAiPCIgKGVsZW1OYW1lICJodG1sIikgYXR0 cmlidXRlcyAiPiIgKG5vcm1hbENvbnRlbnQgIlxuIiAoZWxlbSAobm9ybWFsRWxlbSAiPCIg KGVsZW1OYW1lICJoZWFkIikgYXR0cmlidXRlcyAiPiIgKG5vcm1hbENvbnRlbnQgIlxuICAg ICIgKGVsZW0gKGVzY1Jhd1RleHRFbGVtICI8IiAoZXNjUmF3VGV4dEVsZW1OYW1lICJ0aXRs ZSIpIGF0dHJpYnV0ZXMgIj4iIChlc2NSYXdUZXh0Q29udGVudCAiRXhhbXBsZSBEb21haW4i KSAoZW5kRWxlbSAiPC8iIChlbGVtTmFtZSAidGl0bGUiKSAiPiIpKSkgIlxuICAgICIgKGVs ZW0gKHNlbGZDbG9zaW5nRWxlbSAiPCIgKGVsZW1OYW1lICJtZXRhIikgKGF0dHJpYnV0ZXMg IiAiIChkb3VibGVRdW90ZUF0dHIgKGF0dHJOYW1lICJjaGFyc2V0IikgIj1cInV0Zi04XCIi KSAiICIpICIvPiIpKSAiXG4gICAgIiAoZWxlbSAoc2VsZkNsb3NpbmdFbGVtICI8IiAoZWxl bU5hbWUgIm1ldGEiKSAoYXR0cmlidXRlcyAiICIgKGRvdWJsZVF1b3RlQXR0ciAoYXR0ck5h bWUgImh0dHAtZXF1aXYiKSAiPVwiQ29udGVudC10eXBlXCIiKSAiICIgKGRvdWJsZVF1b3Rl QXR0ciAoYXR0ck5hbWUgImNvbnRlbnQiKSAiPVwidGV4dC9odG1sOyBjaGFyc2V0PXV0Zi04 XCIiKSAiICIpICIvPiIpKSAiXG4gICAgIiAoZWxlbSAoc2VsZkNsb3NpbmdFbGVtICI8IiAo ZWxlbU5hbWUgIm1ldGEiKSAoYXR0cmlidXRlcyAiICIgKGRvdWJsZVF1b3RlQXR0ciAoYXR0 ck5hbWUgIm5hbWUiKSAiPVwidmlld3BvcnRcIiIpICIgIiAoZG91YmxlUXVvdGVBdHRyIChh dHRyTmFtZSAiY29udGVudCIpICI9XCJ3aWR0aD1kZXZpY2Utd2lkdGgsIGluaXRpYWwtc2Nh bGU9MVwiIikgIiAiKSAiLz4iKSkgIlxuICAgICIgKGVsZW0gKHJhd1RleHRFbGVtICI8IiAo cmF3VGV4dEVsZW1OYW1lICJzdHlsZSIpIChhdHRyaWJ1dGVzICIgIiAoZG91YmxlUXVvdGVB dHRyIChhdHRyTmFtZSAidHlwZSIpICI9XCJ0ZXh0L2Nzc1wiIikpICI+IiAocmF3VGV4dENv bnRlbnQgIlxuICAgIGJvZHkge1xuICAgICAgICBiYWNrZ3JvdW5kLWNvbG9yOiAjZjBmMGYy O1xuICAgICAgICBtYXJnaW46IDA7XG4gICAgICAgIHBhZGRpbmc6IDA7XG4gICAgfVxuICAg ICIpIChlbmRFbGVtICI8LyIgKGVsZW1OYW1lICJzdHlsZSIpICI+IikpKSAiXG4iKSAoZW5k RWxlbSAiPC8iIChlbGVtTmFtZSAiaGVhZCIpICI+IikpKSAiXG5cbiIgKGVsZW0gKG5vcm1h bEVsZW0gIjwiIChlbGVtTmFtZSAiYm9keSIpIGF0dHJpYnV0ZXMgIj4iIChub3JtYWxDb250 ZW50ICJcbiIgKGVsZW0gKG5vcm1hbEVsZW0gIjwiIChlbGVtTmFtZSAiZGl2IikgYXR0cmli dXRlcyAiPiIgKG5vcm1hbENvbnRlbnQgIlxuICAgICIgKGVsZW0gKG5vcm1hbEVsZW0gIjwi IChlbGVtTmFtZSAiaDEiKSBhdHRyaWJ1dGVzICI+IiAobm9ybWFsQ29udGVudCAiRXhhbXBs ZSBEb21haW4iKSAoZW5kRWxlbSAiPC8iIChlbGVtTmFtZSAiaDEiKSAiPiIpKSkgIlxuICAg ICIgKGVsZW0gKG5vcm1hbEVsZW0gIjwiIChlbGVtTmFtZSAicCIpIGF0dHJpYnV0ZXMgIj4i IChub3JtYWxDb250ZW50ICJUaGlzIGRvbWFpbiBpcyBmb3IgdXNlIGluIGlsbHVzdHJhdGl2 ZSBleGFtcGxlcyBpbiBkb2N1bWVudHMuIFlvdSBtYXlcbiAgICB1c2UgdGhpcyBkb21haW4g aW4gbGl0ZXJhdHVyZSB3aXRob3V0IHByaW9yIGNvb3JkaW5hdGlvbiBvciBhc2tpbmcgZm9y XG4gICAgcGVybWlzc2lvbi4iKSAoZW5kRWxlbSAiPC8iIChlbGVtTmFtZSAicCIpICI+Iikp KSAiICIgKGVsZW0gKG5vcm1hbEVsZW0gIjwiIChlbGVtTmFtZSAicCIpIGF0dHJpYnV0ZXMg Ij4iIChub3JtYWxDb250ZW50IChlbGVtIChub3JtYWxFbGVtICI8IiAoZWxlbU5hbWUgImEi KSAoYXR0cmlidXRlcyAiICIgKGRvdWJsZVF1b3RlQXR0ciAoYXR0ck5hbWUgImhyZWYiKSAi PVwiaHR0cHM6Ly93d3cuaWFuYS5vcmcvZG9tYWlucy9leGFtcGxlXCIiKSkgIj4iIChub3Jt YWxDb250ZW50ICJNb3JlXG4gICAgaW5mb3JtYXRpb24uLi4iKSAoZW5kRWxlbSAiPC8iIChl bGVtTmFtZSAiYSIpICI+IikpKSkgKGVuZEVsZW0gIjwvIiAoZWxlbU5hbWUgInAiKSAiPiIp KSkgIlxuIikgKGVuZEVsZW0gIjwvIiAoZWxlbU5hbWUgImRpdiIpICI+IikpKSAiXG4iKSAo ZW5kRWxlbSAiPC8iIChlbGVtTmFtZSAiYm9keSIpICI+IikpKSAiXG4iKSAoZW5kRWxlbSAi PC8iIChlbGVtTmFtZSAiaHRtbCIpICI+IikpKSAoYmx1cmIgIlxuIikpKSkpCi0tIAoyLjQ2 LjAKCg== --------------Y2zdP01HIvyrhdt0oeLCmvOa Content-Type: text/x-patch; charset=UTF-8; name="v5-0002-PEG-Add-support-for-not-in-range-and.patch" Content-Disposition: attachment; filename="v5-0002-PEG-Add-support-for-not-in-range-and.patch" Content-Transfer-Encoding: base64 RnJvbSBkODk0MzAzZWQwMWRlNzI3MDNiODE1MDYxZjgyNmRhOTdkZDMwM2YwIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBFa2FpdHogWmFycmFnYSA8ZWthaXR6QGVsZW5xLnRl Y2g+CkRhdGU6IEZyaSwgMTEgT2N0IDIwMjQgMTQ6MjQ6MzAgKzAyMDAKU3ViamVjdDogW1BB VENIIHY1IDIvM10gUEVHOiBBZGQgc3VwcG9ydCBmb3IgYG5vdC1pbi1yYW5nZWAgYW5kIFte Li4uXQoKTW9kZXJuIFBFRyBzdXBwb3J0cyBpbnZlcnNlZCBjbGFzcyBsaWtlIGBbXmEtel1g IHRoYXQgd291bGQgZ2V0IGFueQpjaGFyYWN0ZXIgbm90IGluIHRoZSBgYS16YCByYW5nZS4g VGhpcyBjb21taXQgYWRkcyBzdXBwb3J0IGZvciB0aGF0IGFuZAphbHNvIGZvciBhIG5ldyBg bm90LWluLXJhbmdlYCBQRUcgcGF0dGVybiBmb3Igc2NoZW1lLgoKKiBtb2R1bGUvaWNlLTkv cGVnL2NvZGVnZW4uc2NtIChjZy1ub3QtaW4tcmFuZ2UpOiBOZXcgZnVuY3Rpb24uCiogbW9k dWxlL2ljZS05L3BlZy9zdHJpbmctcGVnLnNjbTogQWRkIHN1cHBvcnQgZm9yIGBbXi4uLl1g CiogdGVzdC1zdWl0ZS90ZXN0cy9wZWcudGVzdDogQWRkIE5vdEluQ2xhc3MgdG8gZ3JhbW1h ci1tYXBwaW5nLgoqIGRvYy9yZWYvYXBpLXBlZy50ZXhpOiBEb2N1bWVudCBhY2NvcmRpbmds eS4KLS0tCiBORVdTICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDMgKystCiBkb2Mv cmVmL2FwaS1wZWcudGV4aSAgICAgICAgICAgIHwgIDggKysrKysrCiBtb2R1bGUvaWNlLTkv cGVnL2NvZGVnZW4uc2NtICAgIHwgMjIgKysrKysrKysrKysrKysrCiBtb2R1bGUvaWNlLTkv cGVnL3N0cmluZy1wZWcuc2NtIHwgNDggKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr LS0tCiB0ZXN0LXN1aXRlL3Rlc3RzL3BlZy50ZXN0ICAgICAgIHwgIDIgKy0KIDUgZmlsZXMg Y2hhbmdlZCwgNzcgaW5zZXJ0aW9ucygrKSwgNiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQg YS9ORVdTIGIvTkVXUwppbmRleCBkZjQzZjM3NTQuLjE3ZWY1NjBiMSAxMDA2NDQKLS0tIGEv TkVXUworKysgYi9ORVdTCkBAIC0zMiw3ICszMiw4IEBAIENoYW5nZXMgaW4gMy4wLjExIChz aW5jZSAzLjAuMTApCiAqKiBQRUcgcGFyc2VyCiAKIFBFRyBwYXJzZXIgaGFzIGJlZW4gcmV3 cml0dGVuIHRvIGNvdmVyIGFsbCB0aGUgZnVuY3Rpb25hbGl0eSBkZWZpbmVkIGluCi08aHR0 cHM6Ly9iZm9yZC5pbmZvL3B1Yi9sYW5nL3BlZy5wZGY+LgorPGh0dHBzOi8vYmZvcmQuaW5m by9wdWIvbGFuZy9wZWcucGRmPi4gQWxzbyBhZGRlZCB0aGUgYG5vdC1pbi1yYW5nZWAgcGF0 dGVybgordG8gYChpY2UtOSBwZWcpYCB0aGF0IGlzIGFsc28gYXZhaWxhYmxlIGZyb20gUEVH IHN0cmluZ3MgdmlhIGBbXi4uLl1gLgogCiAMCiBDaGFuZ2VzIGluIDMuMC4xMCAoc2luY2Ug My4wLjkpCmRpZmYgLS1naXQgYS9kb2MvcmVmL2FwaS1wZWcudGV4aSBiL2RvYy9yZWYvYXBp LXBlZy50ZXhpCmluZGV4IDg0YTllNmM2Yi4uZWRiMDkwYjIwIDEwMDY0NAotLS0gYS9kb2Mv cmVmL2FwaS1wZWcudGV4aQorKysgYi9kb2MvcmVmL2FwaS1wZWcudGV4aQpAQCAtMTQ3LDYg KzE0NywxNCBAQCBQYXJzZXMgYW55IGNoYXJhY3RlciBmYWxsaW5nIGJldHdlZW4gQHZhcnth fSBhbmQgQHZhcnt6fS4KIEBjb2RleyhyYW5nZSAjXGEgI1x6KX0KIEBlbmQgZGVmdHAKIAor QGRlZnRwIHtQRUcgUGF0dGVybn0ge2ludmVyc2UgcmFuZ2Ugb2YgY2hhcmFjdGVyc30gYSB6 CitQYXJzZXMgYW55IGNoYXJhY3RlciBub3QgZmFsbGluZyBiZXR3ZWVuIEB2YXJ7YX0gYW5k IEB2YXJ7en0uCisKK0Bjb2RleyJbXmEtel0ifQorCitAY29kZXsobm90LWluLXJhbmdlICNc YSAjXHopfQorQGVuZCBkZWZ0cAorCiBFeGFtcGxlOgogCiBAZXhhbXBsZQpkaWZmIC0tZ2l0 IGEvbW9kdWxlL2ljZS05L3BlZy9jb2RlZ2VuLnNjbSBiL21vZHVsZS9pY2UtOS9wZWcvY29k ZWdlbi5zY20KaW5kZXggZDgwYzNlODQ5Li44MjM2N2VmNTUgMTAwNjQ0Ci0tLSBhL21vZHVs ZS9pY2UtOS9wZWcvY29kZWdlbi5zY20KKysrIGIvbW9kdWxlL2ljZS05L3BlZy9jb2RlZ2Vu LnNjbQpAQCAtMTQwLDYgKzE0MCwyNyBAQCByZXR1cm4gRVhQLiIKICAgICAgICAgICAgICAg ICAgICAgICAgICAoKG5vbmUpICNgKGxpc3QgKDErIHBvcykgJygpKSkKICAgICAgICAgICAg ICAgICAgICAgICAgICAoZWxzZSAoZXJyb3IgImJhZCBhY2N1bSIgYWNjdW0pKSkpKSkpKSkp CiAKKzs7IEdlbmVyYXRlcyBjb2RlIGZvciBtYXRjaGluZyBhIHJhbmdlIG9mIGNoYXJhY3Rl cnMgbm90IGJldHdlZW4gc3RhcnQgYW5kIGVuZC4KKzs7IEUuZy46IChjZy1ub3QtaW4tcmFu Z2Ugc3ludGF4ICNcYSAjXHogJ2JvZHkpCisoZGVmaW5lIChjZy1ub3QtaW4tcmFuZ2UgcGF0 IGFjY3VtKQorICAoc3ludGF4LWNhc2UgcGF0ICgpCisgICAgKChzdGFydCBlbmQpCisgICAg IChpZiAobm90IChhbmQgKGNoYXI/IChzeW50YXgtPmRhdHVtICMnc3RhcnQpKQorICAgICAg ICAgICAgICAgICAgIChjaGFyPyAoc3ludGF4LT5kYXR1bSAjJ2VuZCkpKSkKKyAgICAgICAg IChlcnJvciAicmFuZ2UgUEVHIHNob3VsZCBoYXZlIGNoYXJhY3RlcnMgYWZ0ZXIgaXQ7IGlu c3RlYWQgZ290IgorICAgICAgICAgICAgICAgICMnc3RhcnQgIydlbmQpKQorICAgICAjYChs YW1iZGEgKHN0ciBsZW4gcG9zKQorICAgICAgICAgKGFuZCAoPCBwb3MgbGVuKQorICAgICAg ICAgICAgICAobGV0ICgoYyAoc3RyaW5nLXJlZiBzdHIgcG9zKSkpCisgICAgICAgICAgICAg ICAgKGFuZCAob3IgKGNoYXI8PyBjIHN0YXJ0KSAoY2hhcj4/IGMgZW5kKSkKKyAgICAgICAg ICAgICAgICAgICAgICMsKGNhc2UgYWNjdW0KKyAgICAgICAgICAgICAgICAgICAgICAgICAo KGFsbCkgI2AobGlzdCAoMSsgcG9zKQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIChsaXN0ICdjZy1ub3QtaW4tcmFuZ2UgKHN0cmluZyBjKSkpKQorICAgICAg ICAgICAgICAgICAgICAgICAgICgobmFtZSkgI2AobGlzdCAoMSsgcG9zKSAnY2ctbm90LWlu LXJhbmdlKSkKKyAgICAgICAgICAgICAgICAgICAgICAgICAoKGJvZHkpICNgKGxpc3QgKDEr IHBvcykgKHN0cmluZyBjKSkpCisgICAgICAgICAgICAgICAgICAgICAgICAgKChub25lKSAj YChsaXN0ICgxKyBwb3MpICcoKSkpCisgICAgICAgICAgICAgICAgICAgICAgICAgKGVsc2Ug KGVycm9yICJiYWQgYWNjdW0iIGFjY3VtKSkpKSkpKSkpKQorCiA7OyBHZW5lcmF0ZSBjb2Rl IHRvIG1hdGNoIGEgcGF0dGVybiBhbmQgZG8gbm90aGluZyB3aXRoIHRoZSByZXN1bHQKIChk ZWZpbmUgKGNnLWlnbm9yZSBwYXQgYWNjdW0pCiAgIChzeW50YXgtY2FzZSBwYXQgKCkKQEAg LTMwNCw2ICszMjUsNyBAQCByZXR1cm4gRVhQLiIKICAgICAgICAgKGFzc3Etc2V0ISBwZWct Y29tcGlsZXItYWxpc3Qgc3ltYm9sIGZ1bmN0aW9uKSkpCiAKIChhZGQtcGVnLWNvbXBpbGVy ISAncmFuZ2UgY2ctcmFuZ2UpCisoYWRkLXBlZy1jb21waWxlciEgJ25vdC1pbi1yYW5nZSBj Zy1ub3QtaW4tcmFuZ2UpCiAoYWRkLXBlZy1jb21waWxlciEgJ2lnbm9yZSBjZy1pZ25vcmUp CiAoYWRkLXBlZy1jb21waWxlciEgJ2NhcHR1cmUgY2ctY2FwdHVyZSkKIChhZGQtcGVnLWNv bXBpbGVyISAnYW5kIGNnLWFuZCkKZGlmZiAtLWdpdCBhL21vZHVsZS9pY2UtOS9wZWcvc3Ry aW5nLXBlZy5zY20gYi9tb2R1bGUvaWNlLTkvcGVnL3N0cmluZy1wZWcuc2NtCmluZGV4IGVk ZTI0MTgxYy4uNGI5MmIzOTNjIDEwMDY0NAotLS0gYS9tb2R1bGUvaWNlLTkvcGVnL3N0cmlu Zy1wZWcuc2NtCisrKyBiL21vZHVsZS9pY2UtOS9wZWcvc3RyaW5nLXBlZy5zY20KQEAgLTU0 LDcgKzU0LDcgQEAgUHJlZml4IDwtLSAoQU5EIC8gTk9UKT8gU3VmZml4CiBTdWZmaXggPC0t IFByaW1hcnkgKFFVRVNUSU9OIC8gU1RBUiAvIFBMVVMpPwogUHJpbWFyeSA8LS0gSWRlbnRp ZmllciAhTEVGVEFSUk9XCiAgICAgICAgICAgIC8gT1BFTiBFeHByZXNzaW9uIENMT1NFCi0g ICAgICAgICAgIC8gTGl0ZXJhbCAvIENsYXNzIC8gRE9UCisgICAgICAgICAgIC8gTGl0ZXJh bCAvIENsYXNzIC8gTm90SW5DbGFzcyAvIERPVAogCiAjIExleGljYWwgc3ludGF4CiBJZGVu dGlmaWVyIDwtLSBJZGVudFN0YXJ0IElkZW50Q29udCogU3BhY2luZwpAQCAtNjQsNyArNjQs OCBAQCBJZGVudENvbnQgPC0gSWRlbnRTdGFydCAvIFswLTldCiAKIExpdGVyYWwgPC0tIFNR VU9URSAoIVNRVU9URSBDaGFyKSogU1FVT1RFIFNwYWNpbmcKICAgICAgICAgLyBEUVVPVEUg KCFEUVVPVEUgQ2hhcikqIERRVU9URSBTcGFjaW5nCi1DbGFzcyA8LS0gT1BFTkJSQUNLRVQg KCFDTE9TRUJSQUNLRVQgUmFuZ2UpKiBDTE9TRUJSQUNLRVQgU3BhY2luZworTm90SW5DbGFz cyA8LS0gT1BFTkJSQUNLRVQgTk9USU4gICghQ0xPU0VCUkFDS0VUIFJhbmdlKSogQ0xPU0VC UkFDS0VUIFNwYWNpbmcKK0NsYXNzIDwtLSBPUEVOQlJBQ0tFVCAhTk9USU4gICghQ0xPU0VC UkFDS0VUIFJhbmdlKSogQ0xPU0VCUkFDS0VUIFNwYWNpbmcKIFJhbmdlIDwtLSBDaGFyIERB U0ggQ2hhciAvIENoYXIKIENoYXIgPC0tICdcXFxcJyBbbnJ0ZidcIlxcW1xcXVxcXFxdCiAg ICAgICAgLyAnXFxcXCcgWzAtN11bMC03XVswLTddCkBAIC04MCw2ICs4MSw3IEBAIERBU0gg PCAnLScKIE9QRU5CUkFDS0VUIDwgJ1snCiBDTE9TRUJSQUNLRVQgPCAnXScKIEhFWCA8LSBb MC05YS1mQS1GXQorTk9USU4gPCAnXicKIFNMQVNIIDwgJy8nIFNwYWNpbmcKIEFORCA8LS0g JyYnIFNwYWNpbmcKIE5PVCA8LS0gJyEnIFNwYWNpbmcKQEAgLTEyNCw2ICsxMjYsNyBAQCBF bmRPZkZpbGUgPCAhLgogICAgICAgKGFuZCBPUEVOIEV4cHJlc3Npb24gQ0xPU0UpCiAgICAg ICBMaXRlcmFsCiAgICAgICBDbGFzcworICAgICAgTm90SW5DbGFzcwogICAgICAgRE9UKSkK IChkZWZpbmUtc2V4cC1wYXJzZXIgSWRlbnRpZmllciBhbGwKICAgKGFuZCBJZGVudFN0YXJ0 ICgqIElkZW50Q29udCkgU3BhY2luZykpCkBAIC0xMzUsNyArMTM4LDExIEBAIEVuZE9mRmls ZSA8ICEuCiAgIChvciAoYW5kIFNRVU9URSAoKiAoYW5kIChub3QtZm9sbG93ZWQtYnkgU1FV T1RFKSBDaGFyKSkgU1FVT1RFIFNwYWNpbmcpCiAgICAgICAoYW5kIERRVU9URSAoKiAoYW5k IChub3QtZm9sbG93ZWQtYnkgRFFVT1RFKSBDaGFyKSkgRFFVT1RFIFNwYWNpbmcpKSkKIChk ZWZpbmUtc2V4cC1wYXJzZXIgQ2xhc3MgYWxsCi0gIChhbmQgT1BFTkJSQUNLRVQgKCogKGFu ZCAobm90LWZvbGxvd2VkLWJ5IENMT1NFQlJBQ0tFVCkgUmFuZ2UpKSBDTE9TRUJSQUNLRVQg U3BhY2luZykpCisgIChhbmQgT1BFTkJSQUNLRVQgKG5vdC1mb2xsb3dlZC1ieSBOT1RJTikK KyAgICAgICAoKiAoYW5kIChub3QtZm9sbG93ZWQtYnkgQ0xPU0VCUkFDS0VUKSBSYW5nZSkp IENMT1NFQlJBQ0tFVCBTcGFjaW5nKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgTm90SW5DbGFz cyBhbGwKKyAgKGFuZCBPUEVOQlJBQ0tFVCBOT1RJTgorICAgICAgICgqIChhbmQgKG5vdC1m b2xsb3dlZC1ieSBDTE9TRUJSQUNLRVQpIFJhbmdlKSkgQ0xPU0VCUkFDS0VUIFNwYWNpbmcp KQogKGRlZmluZS1zZXhwLXBhcnNlciBSYW5nZSBhbGwKICAgKG9yIChhbmQgQ2hhciBEQVNI IENoYXIpIENoYXIpKQogKGRlZmluZS1zZXhwLXBhcnNlciBDaGFyIGFsbApAQCAtMTQ4LDYg KzE1NSw4IEBAIEVuZE9mRmlsZSA8ICEuCiAgIChhbmQgKG9yICI8LS0iICI8LSIgIjwiKSBT cGFjaW5nKSkgOyBOT1RFOiA8LS0gYW5kIDwgYXJlIGV4dGVuc2lvbnMKIChkZWZpbmUtc2V4 cC1wYXJzZXIgSEVYIGJvZHkKICAgKG9yIChyYW5nZSAjXDAgI1w5KSAocmFuZ2UgI1xhICNc ZikgKHJhbmdlICNcQSAjXEYpKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgTk9USU4gbm9uZQor ICAoYW5kICJeIikpCiAoZGVmaW5lLXNleHAtcGFyc2VyIFNMQVNIIG5vbmUKICAgKGFuZCAi LyIgU3BhY2luZykpCiAoZGVmaW5lLXNleHAtcGFyc2VyIEFORCBhbGwKQEAgLTI4NCw2ICsy OTMsNyBAQCBFbmRPZkZpbGUgPCAhLgogICAgICAgKCdJZGVudGlmaWVyIChJZGVudGlmaWVy LT5kZWZuIHZhbHVlIGZvci1zeW50YXgpKQogICAgICAgKCdFeHByZXNzaW9uIChFeHByZXNz aW9uLT5kZWZuIHZhbHVlIGZvci1zeW50YXgpKQogICAgICAgKCdMaXRlcmFsICAgIChMaXRl cmFsLT5kZWZuIHZhbHVlIGZvci1zeW50YXgpKQorICAgICAgKCdOb3RJbkNsYXNzIChOb3RJ bkNsYXNzLT5kZWZuIHZhbHVlIGZvci1zeW50YXgpKQogICAgICAgKCdDbGFzcyAgICAgIChD bGFzcy0+ZGVmbiB2YWx1ZSBmb3Itc3ludGF4KSkpKSkKIAogOzsgKElkZW50aWZpZXIgImhl bGxvIikKQEAgLTI5NiwxMyArMzA2LDQzIEBAIEVuZE9mRmlsZSA8ICEuCiAoZGVmaW5lIChM aXRlcmFsLT5kZWZuIGxzdCBmb3Itc3ludGF4KQogICAoYXBwbHkgc3RyaW5nIChtYXAgKGxh bWJkYSAoeCkgKENoYXItPmRlZm4geCBmb3Itc3ludGF4KSkgKGNkciBsc3QpKSkpCiAKLTs7 IFRPRE86IGVtcHR5IENsYXNzIGNhbiBoYXBwZW46IGBbXWAsIGJ1dCB3aGF0IGRvZXMgaXQg cmVwcmVzZW50PworOzsgKE5vdEluQ2xhc3MgKFJhbmdlIC4uLikgKFJhbmdlIC4uLikpCis7 OyAgYC0+IChhbmQgKGZvbGxvd2VkLWJ5IChub3QtaW4tcmFuZ2UgLi4uKSkKKzs7ICAgICAg ICAgICAoZm9sbG93ZWQtYnkgKG5vdC1pbi1yYW5nZSAuLi4pKQorOzsgICAgICAgICAgIC4u LgorOzsgICAgICAgICAgIChub3QtaW4tcmFuZ2UgLi4uKSkKKzs7IE5PVEU6IHRoZSBvcmRl ciBkb2Vzbid0IG1hdHRlciwgYmVjYXVzZSBhbGwgYG5vdC1pbi1yYW5nZWBzIHdpbGwgYWx3 YXlzCis7OyBwYXJzZSBleGFjdGx5IG9uZSBjaGFyYWN0ZXIsIGJ1dCBhbGwgdGhlIGVsZW1l bnRzIGJ1dCB0aGUgbGFzdCBuZWVkIG5vdCB0bworOzsgY29uc3VtZSB0aGUgaW5wdXQuCiso ZGVmaW5lIChOb3RJbkNsYXNzLT5kZWZuIGxzdCBmb3Itc3ludGF4KQorICAjYChhbmQKKyAg ICAgICMsQChtYXAgKGxhbWJkYSAoeCkgI2AoZm9sbG93ZWQtYnkgIywoTm90SW5SYW5nZS0+ ZGVmbiB4IGZvci1zeW50YXgpKSkKKyAgICAgICAgICAgICAgKGNkZHIgbHN0KSkKKyAgICAg ICMsKE5vdEluUmFuZ2UtPmRlZm4gKGNhZHIgbHN0KSBmb3Itc3ludGF4KSkpCisKIDs7IChD bGFzcyAuLi4pCiA7OyAgYC0+IChvciAuLi4pCiAoZGVmaW5lIChDbGFzcy0+ZGVmbiBsc3Qg Zm9yLXN5bnRheCkKICAgI2Aob3IgIyxAKG1hcCAobGFtYmRhICh4KSAoUmFuZ2UtPmRlZm4g eCBmb3Itc3ludGF4KSkKICAgICAgICAgICAgICAgICAoY2RyIGxzdCkpKSkKIAorOzsgRm9y IG9uZSBjaGFyYWN0ZXI6Cis7OyAoUmFuZ2UgKENoYXIgImEiKSkKKzs7ICBgLT4gKG5vdC1p bi1yYW5nZSAjXGEgI1xhKQorOzsgT3IgZm9yIGEgcmFuZ2U6Cis7OyAoUmFuZ2UgKENoYXIg ImEiKSAoQ2hhciAiYiIpKQorOzsgIGAtPiAobm90LWluLXJhbmdlICNcYSAjXGIpCis7OyBO T1RFOiBJdCdzIGNvbWluZyBmcm9tIE5vdEluQ2xhc3MuCisoZGVmaW5lIChOb3RJblJhbmdl LT5kZWZuIGxzdCBmb3Itc3ludGF4KQorICAobWF0Y2ggbHN0CisgICAgKCgnUmFuZ2UgYykK KyAgICAgKGxldCAoKGNoIChDaGFyLT5kZWZuIGMgZm9yLXN5bnRheCkpKQorICAgICAgICNg KG5vdC1pbi1yYW5nZSAjLGNoICMsY2gpKSkKKyAgICAoKCdSYW5nZSByYW5nZS1iZWdpbm5p bmcgcmFuZ2UtZW5kKQorICAgICAjYChub3QtaW4tcmFuZ2UKKyAgICAgICAgICMsKENoYXIt PmRlZm4gcmFuZ2UtYmVnaW5uaW5nIGZvci1zeW50YXgpCisgICAgICAgICAjLChDaGFyLT5k ZWZuIHJhbmdlLWVuZCAgICAgICBmb3Itc3ludGF4KSkpKSkKKwogOzsgRm9yIG9uZSBjaGFy YWN0ZXI6CiA7OyAoUmFuZ2UgKENoYXIgImEiKSkKIDs7ICBgLT4gImEiCmRpZmYgLS1naXQg YS90ZXN0LXN1aXRlL3Rlc3RzL3BlZy50ZXN0IGIvdGVzdC1zdWl0ZS90ZXN0cy9wZWcudGVz dAppbmRleCAxMTM2YzAzZjEuLjU1NzBmYmZhOCAxMDA2NDQKLS0tIGEvdGVzdC1zdWl0ZS90 ZXN0cy9wZWcudGVzdAorKysgYi90ZXN0LXN1aXRlL3Rlc3RzL3BlZy50ZXN0CkBAIC0zOCw2 ICszOCw3IEBACiAgICAgKElkZW50aWZpZXIgSWRlbnRpZmllcikKICAgICAoTGl0ZXJhbCBM aXRlcmFsKQogICAgIChDbGFzcyBDbGFzcykKKyAgICAoTm90SW5DbGFzcyBOb3RJbkNsYXNz KQogICAgIChSYW5nZSBSYW5nZSkKICAgICAoQ2hhciBDaGFyKQogICAgIChMRUZUQVJST1cg TEVGVEFSUk9XKQpAQCAtMjgzLDQgKzI4NCwzIEBAIG51bWJlciA8LS0gWzAtOV0rIikKICAg ICIxKzEvMiozKygxKzEpLzIiCiAgICAoZXF1YWw/IChlcS1wYXJzZSAiMSsxLzIqMysoMSsx KS8yIikKIAkgICAnKCsgKCsgMSAoKiAoLyAxIDIpIDMpKSAoLyAoKyAxIDEpIDIpKSkpKQot Ci0tIAoyLjQ2LjAKCg== --------------Y2zdP01HIvyrhdt0oeLCmvOa Content-Type: text/x-patch; charset=UTF-8; name="v5-0001-PEG-Add-full-support-for-PEG-some-extensions.patch" Content-Disposition: attachment; filename*0="v5-0001-PEG-Add-full-support-for-PEG-some-extensions.patch" Content-Transfer-Encoding: base64 RnJvbSBhYTM1ZGIzY2JjNjkxYjU3Yzg1Mzc0ZDZhMjY5ZThkMzQ0YTA0NDBhIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBFa2FpdHogWmFycmFnYSA8ZWthaXR6QGVsZW5xLnRl Y2g+CkRhdGU6IFdlZCwgMTEgU2VwIDIwMjQgMjE6MTk6MjYgKzAyMDAKU3ViamVjdDogW1BB VENIIHY1IDEvM10gUEVHOiBBZGQgZnVsbCBzdXBwb3J0IGZvciBQRUcgKyBzb21lIGV4dGVu c2lvbnMKClRoaXMgY29tbWl0IGFkZHMgc3VwcG9ydCBmb3IgUEVHIGFzIGRlc2NyaWJlZCBp bjoKCiAgICA8aHR0cHM6Ly9iZm9yZC5pbmZvL3B1Yi9sYW5nL3BlZy5wZGY+CgpJdCBhZGRz IHN1cHBvcnQgZm9yIHRoZSBtaXNzaW5nIGZlYXR1cmVzIChjb21tZW50cywgdW5kZXJzY29y ZXMgaW4KaWRlbnRpZmllcnMgYW5kIGVzY2FwaW5nKSB3aGlsZSBrZWVwaW5nIHRoZSBleHRl bnNpb25zIChkYXNoZXMgaW4KaWRlbnRpZmllcnMsIDwgYW5kIDwtLSkuCgpUaGUgbmFtaW5n IHN5c3RlbSB0cmllcyB0byBiZSBhcyBjbG9zZSBhcyBwb3NzaWJsZSB0byB0aGUgb25lIHBy b3Bvc2VkCmluIHRoZSBwYXBlci4KCiogbW9kdWxlL2ljZS05L3BlZy9zdHJpbmctcGVnLnNj bTogUmV3cml0ZSBQRUcgcGFyc2VyLgoqIHRlc3Qtc3VpdGUvdGVzdHMvcGVnLnRlc3Q6IEZp eCBpbXBvcnQKLS0tCiBORVdTICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICA3ICsK IGRvYy9yZWYvYXBpLXBlZy50ZXhpICAgICAgICAgICAgfCAgIDggKy0KIG1vZHVsZS9pY2Ut OS9wZWcvc3RyaW5nLXBlZy5zY20gfCA0NjYgKysrKysrKysrKysrKysrKysrKystLS0tLS0t LS0tLS0KIHRlc3Qtc3VpdGUvdGVzdHMvcGVnLnRlc3QgICAgICAgfCAgMzIgKystCiA0IGZp bGVzIGNoYW5nZWQsIDMzMyBpbnNlcnRpb25zKCspLCAxODAgZGVsZXRpb25zKC0pCgpkaWZm IC0tZ2l0IGEvTkVXUyBiL05FV1MKaW5kZXggOWZkMTRjMzlkLi5kZjQzZjM3NTQgMTAwNjQ0 Ci0tLSBhL05FV1MKKysrIGIvTkVXUwpAQCAtMjcsNiArMjcsMTMgQEAgQ2hhbmdlcyBpbiAz LjAuMTEgKHNpbmNlIDMuMC4xMCkKICoqIEd1aWxlIGlzIGNvbXBpbGVkIHdpdGggLWZleGNl c3MtcHJlY2lzaW9uPXN0YW5kYXJkIGZvciBpWzM0NTZdODYgd2hlbiBwb3NzaWJsZQogICAg KDxodHRwczovL2RlYmJ1Z3MuZ251Lm9yZy80MzI2Mj4pCiAKKyogTmV3IGludGVyZmFjZXMg YW5kIGZ1bmN0aW9uYWxpdHkKKworKiogUEVHIHBhcnNlcgorCitQRUcgcGFyc2VyIGhhcyBi ZWVuIHJld3JpdHRlbiB0byBjb3ZlciBhbGwgdGhlIGZ1bmN0aW9uYWxpdHkgZGVmaW5lZCBp bgorPGh0dHBzOi8vYmZvcmQuaW5mby9wdWIvbGFuZy9wZWcucGRmPi4KKwogDAogQ2hhbmdl cyBpbiAzLjAuMTAgKHNpbmNlIDMuMC45KQogCmRpZmYgLS1naXQgYS9kb2MvcmVmL2FwaS1w ZWcudGV4aSBiL2RvYy9yZWYvYXBpLXBlZy50ZXhpCmluZGV4IGQzNGRkYzY0Yy4uODRhOWU2 YzZiIDEwMDY0NAotLS0gYS9kb2MvcmVmL2FwaS1wZWcudGV4aQorKysgYi9kb2MvcmVmL2Fw aS1wZWcudGV4aQpAQCAtMTcsNiArMTcsMTAgQEAgV2lraXBlZGlhIGhhcyBhIGNsZWFyIGFu ZCBjb25jaXNlIGludHJvZHVjdGlvbiB0byBQRUdzIGlmIHlvdSB3YW50IHRvCiBmYW1pbGlh cml6ZSB5b3Vyc2VsZiB3aXRoIHRoZSBzeW50YXg6CiBAdXJse2h0dHA6Ly9lbi53aWtpcGVk aWEub3JnL3dpa2kvUGFyc2luZ19leHByZXNzaW9uX2dyYW1tYXJ9LgogCitUaGUgcGFwZXIg dGhhdCBpbnRyb2R1Y2VkIFBFRyBjb250YWlucyBhIG1vcmUgZGV0YWlsZWQgZGVzY3JpcHRp b24gb2YgaG93IFBFRword29ya3MsIGFuZCBkZXNjcmliZXMgaXRzIHN5bnRheCBpbiBkZXRh aWw6CitAdXJse2h0dHBzOi8vYmZvcmQuaW5mby9wdWIvbGFuZy9wZWcucGRmfQorCiBUaGUg QGNvZGV7KGljZS05IHBlZyl9IG1vZHVsZSB3b3JrcyBieSBjb21waWxpbmcgUEVHcyBkb3du IHRvIGxhbWJkYQogZXhwcmVzc2lvbnMuICBUaGVzZSBjYW4gZWl0aGVyIGJlIHN0b3JlZCBp biB2YXJpYWJsZXMgYXQgY29tcGlsZS10aW1lIGJ5CiB0aGUgZGVmaW5lIG1hY3JvcyAoQGNv ZGV7ZGVmaW5lLXBlZy1wYXR0ZXJufSBhbmQKQEAgLTIxNiw4ICsyMjAsOCBAQCBzaG91bGQg cHJvcGFnYXRlIHVwIHRoZSBwYXJzZSB0cmVlLiAgVGhlIG5vcm1hbCBAY29kZXs8LX0gcHJv cGFnYXRlcyB0aGUKIG1hdGNoZWQgdGV4dCB1cCB0aGUgcGFyc2UgdHJlZSwgQGNvZGV7PC0t fSBwcm9wYWdhdGVzIHRoZSBtYXRjaGVkIHRleHQKIHVwIHRoZSBwYXJzZSB0cmVlIHRhZ2dl ZCB3aXRoIHRoZSBuYW1lIG9mIHRoZSBub250ZXJtaW5hbCwgYW5kIEBjb2Rlezx9CiBkaXNj YXJkcyB0aGF0IG1hdGNoZWQgdGV4dCBhbmQgcHJvcGFnYXRlcyBub3RoaW5nIHVwIHRoZSBw YXJzZSB0cmVlLgotQWxzbywgbm9udGVybWluYWxzIG1heSBjb25zaXN0IG9mIGFueSBhbHBo YW51bWVyaWMgY2hhcmFjdGVyIG9yIGEgYGAtJycKLWNoYXJhY3RlciAoaW4gbm9ybWFsIFBF R3Mgbm9udGVybWluYWxzIGNhbiBvbmx5IGJlIGFscGhhYmV0aWMpLgorQWxzbywgbm9udGVy bWluYWxzIG1heSBpbmNsdWRlIGBgLScnIGNoYXJhY3Rlciwgd2hpbGUgaW4gbm9ybWFsIFBF RyBpdCBpcyBub3QKK2FsbG93ZWQuCiAKIEZvciBleGFtcGxlLCBpZiB3ZToKIEBsaXNwCmRp ZmYgLS1naXQgYS9tb2R1bGUvaWNlLTkvcGVnL3N0cmluZy1wZWcuc2NtIGIvbW9kdWxlL2lj ZS05L3BlZy9zdHJpbmctcGVnLnNjbQppbmRleCA0NWVkMTRiYjEuLmVkZTI0MTgxYyAxMDA2 NDQKLS0tIGEvbW9kdWxlL2ljZS05L3BlZy9zdHJpbmctcGVnLnNjbQorKysgYi9tb2R1bGUv aWNlLTkvcGVnL3N0cmluZy1wZWcuc2NtCkBAIC0xLDYgKzEsNyBAQAogOzs7OyBzdHJpbmct cGVnLnNjbSAtLS0gcmVwcmVzZW50aW5nIFBFRyBncmFtbWFycyBhcyBzdHJpbmdzCiA7Ozs7 Ci07Ozs7IAlDb3B5cmlnaHQgKEMpIDIwMTAsIDIwMTEgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uLCBJbmMuCis7Ozs7IAlDb3B5cmlnaHQgKEMpIDIwMTAsIDIwMTEsIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbiwgSW5jLgorOzs7OyAJQ29weXJpZ2h0IChDKSAyMDI0IEVrYWl0eiBa YXJyYWdhIDxla2FpdHpAZWxlbnEudGVjaD4KIDs7OzsKIDs7OzsgVGhpcyBsaWJyYXJ5IGlz IGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogOzs7OyBt b2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVi bGljCkBAIC0yMSwxMCArMjIsMTUgQEAKICAgIzpleHBvcnQgKHBlZy1hcy1wZWcKICAgICAg ICAgICAgIGRlZmluZS1wZWctc3RyaW5nLXBhdHRlcm5zCiAgICAgICAgICAgICBwZWctZ3Jh bW1hcikKKyAgIzp1c2UtbW9kdWxlIChpY2UtOSBtYXRjaCkKICAgIzp1c2UtbW9kdWxlIChp Y2UtOSBwZWcgdXNpbmctcGFyc2VycykKKyAgIzp1c2UtbW9kdWxlIChzcmZpIHNyZmktMSkK ICAgIzp1c2UtbW9kdWxlIChpY2UtOSBwZWcgY29kZWdlbikKICAgIzp1c2UtbW9kdWxlIChp Y2UtOSBwZWcgc2ltcGxpZnktdHJlZSkpCiAKKzs7IFRoaXMgbW9kdWxlIHByb3ZpZGVzIHN1 cHBvcnQgZm9yIFBFRyBhcyBkZXNjcmliZWQgaW46Cis7OyAgIDxodHRwczovL2Jmb3JkLmlu Zm8vcHViL2xhbmcvcGVnLnBkZj4KKwogOzsgR2V0cyB0aGUgbGVmdC1oYW5kIGRlcHRoIG9m IGEgbGlzdC4KIChkZWZpbmUgKGRlcHRoIGxzdCkKICAgKGlmIChvciAobm90IChsaXN0PyBs c3QpKSAobnVsbD8gbHN0KSkKQEAgLTM4LDIyICs0NCw2MCBAQAogCiA7OyBHcmFtbWFyIGZv ciBQRUdzIGluIFBFRyBncmFtbWFyLgogKGRlZmluZSBwZWctYXMtcGVnCi0iZ3JhbW1hciA8 LS0gKG5vbnRlcm1pbmFsICgnPC0tJyAvICc8LScgLyAnPCcpIHNwIHBhdHRlcm4pKwotcGF0 dGVybiA8LS0gYWx0ZXJuYXRpdmUgKFNMQVNIIHNwIGFsdGVybmF0aXZlKSoKLWFsdGVybmF0 aXZlIDwtLSAoWyEmXT8gc3Agc3VmZml4KSsKLXN1ZmZpeCA8LS0gcHJpbWFyeSAoWyorP10g c3ApKgotcHJpbWFyeSA8LS0gJygnIHNwIHBhdHRlcm4gJyknIHNwIC8gJy4nIHNwIC8gbGl0 ZXJhbCAvIGNoYXJjbGFzcyAvIG5vbnRlcm1pbmFsICEnPCcKLWxpdGVyYWwgPC0tIFsnXSAo IVsnXSAuKSogWyddIHNwCi1jaGFyY2xhc3MgPC0tIExCICghJ10nIChDQ3JhbmdlIC8gQ0Nz aW5nbGUpKSogUkIgc3AKLUNDcmFuZ2UgPC0tIC4gJy0nIC4KLUNDc2luZ2xlIDwtLSAuCi1u b250ZXJtaW5hbCA8LS0gW2EtekEtWjAtOS1dKyBzcAotc3AgPCBbIFx0XG5dKgotU0xBU0gg PCAnLycKLUxCIDwgJ1snCi1SQiA8ICddJworIiMgSGllcmFyY2hpY2FsIHN5bnRheAorR3Jh bW1hciA8LS0gU3BhY2luZyBEZWZpbml0aW9uKyBFbmRPZkZpbGUKK0RlZmluaXRpb24gPC0t IElkZW50aWZpZXIgTEVGVEFSUk9XIEV4cHJlc3Npb24KKworRXhwcmVzc2lvbiA8LS0gU2Vx dWVuY2UgKFNMQVNIIFNlcXVlbmNlKSoKK1NlcXVlbmNlIDwtLSBQcmVmaXgqCitQcmVmaXgg PC0tIChBTkQgLyBOT1QpPyBTdWZmaXgKK1N1ZmZpeCA8LS0gUHJpbWFyeSAoUVVFU1RJT04g LyBTVEFSIC8gUExVUyk/CitQcmltYXJ5IDwtLSBJZGVudGlmaWVyICFMRUZUQVJST1cKKyAg ICAgICAgICAgLyBPUEVOIEV4cHJlc3Npb24gQ0xPU0UKKyAgICAgICAgICAgLyBMaXRlcmFs IC8gQ2xhc3MgLyBET1QKKworIyBMZXhpY2FsIHN5bnRheAorSWRlbnRpZmllciA8LS0gSWRl bnRTdGFydCBJZGVudENvbnQqIFNwYWNpbmcKKyMgTk9URTogYC1gIGlzIGFuIGV4dGVuc2lv bgorSWRlbnRTdGFydCA8LSBbYS16QS1aX10gLyAnLScKK0lkZW50Q29udCA8LSBJZGVudFN0 YXJ0IC8gWzAtOV0KKworTGl0ZXJhbCA8LS0gU1FVT1RFICghU1FVT1RFIENoYXIpKiBTUVVP VEUgU3BhY2luZworICAgICAgICAvIERRVU9URSAoIURRVU9URSBDaGFyKSogRFFVT1RFIFNw YWNpbmcKK0NsYXNzIDwtLSBPUEVOQlJBQ0tFVCAoIUNMT1NFQlJBQ0tFVCBSYW5nZSkqIENM T1NFQlJBQ0tFVCBTcGFjaW5nCitSYW5nZSA8LS0gQ2hhciBEQVNIIENoYXIgLyBDaGFyCitD aGFyIDwtLSAnXFxcXCcgW25ydGYnXCJcXFtcXF1cXFxcXQorICAgICAgIC8gJ1xcXFwnIFsw LTddWzAtN11bMC03XQorICAgICAgIC8gJ1xcXFwnIFswLTddWzAtN10/CisgICAgICAgLyAn XFxcXCcgJ3UnIEhFWCBIRVggSEVYIEhFWAorICAgICAgIC8gISdcXFxcJyAuCisKKyMgTk9U RTogYDwtLWAgYW5kIGA8YCBhcmUgZXh0ZW5zaW9ucworTEVGVEFSUk9XIDwtICgnPC0tJyAv ICc8LScgLyAnPCcpIFNwYWNpbmcKK1NRVU9URSA8IFsnXQorRFFVT1RFIDwgW1wiXQorREFT SCA8ICctJworT1BFTkJSQUNLRVQgPCAnWycKK0NMT1NFQlJBQ0tFVCA8ICddJworSEVYIDwt IFswLTlhLWZBLUZdCitTTEFTSCA8ICcvJyBTcGFjaW5nCitBTkQgPC0tICcmJyBTcGFjaW5n CitOT1QgPC0tICchJyBTcGFjaW5nCitRVUVTVElPTiA8LS0gJz8nIFNwYWNpbmcKK1NUQVIg PC0tICcqJyBTcGFjaW5nCitQTFVTIDwtLSAnKycgU3BhY2luZworT1BFTiA8ICcoJyBTcGFj aW5nCitDTE9TRSA8ICcpJyBTcGFjaW5nCitET1QgPC0tICcuJyBTcGFjaW5nCisKK1NwYWNp bmcgPCAoU3BhY2UgLyBDb21tZW50KSoKK0NvbW1lbnQgPCAnIycgKCFFbmRPZkxpbmUgLikq IEVuZE9mTGluZQorU3BhY2UgPCAnICcgLyAnXFx0JyAvIEVuZE9mTGluZQorRW5kT2ZMaW5l IDwgJ1xcclxcbicgLyAnXFxuJyAvICdcXHInCitFbmRPZkZpbGUgPCAhLgogIikKIAorCiAo ZGVmaW5lLXN5bnRheCBkZWZpbmUtc2V4cC1wYXJzZXIKICAgKGxhbWJkYSAoeCkKICAgICAo c3ludGF4LWNhc2UgeCAoKQpAQCAtNjMsMzUgKzEwNyw4MSBAQCBSQiA8ICddJwogICAgICAg ICAgICAgICAoc3luICh3cmFwLXBhcnNlci1mb3ItdXNlcnMgeCBtYXRjaGYgYWNjdW1zeW0g IydzeW0pKSkKICAgICAgICAgICAgI2AoZGVmaW5lIHN5bSAjLHN5bikpKSkpKQogCi0oZGVm aW5lLXNleHAtcGFyc2VyIHBlZy1ncmFtbWFyIGFsbAotICAoKyAoYW5kIHBlZy1ub250ZXJt aW5hbCAob3IgIjwtLSIgIjwtIiAiPCIpIHBlZy1zcCBwZWctcGF0dGVybikpKQotKGRlZmlu ZS1zZXhwLXBhcnNlciBwZWctcGF0dGVybiBhbGwKLSAgKGFuZCBwZWctYWx0ZXJuYXRpdmUK LSAgICAgICAoKiAoYW5kIChpZ25vcmUgIi8iKSBwZWctc3AgcGVnLWFsdGVybmF0aXZlKSkp KQotKGRlZmluZS1zZXhwLXBhcnNlciBwZWctYWx0ZXJuYXRpdmUgYWxsCi0gICgrIChhbmQg KD8gKG9yICIhIiAiJiIpKSBwZWctc3AgcGVnLXN1ZmZpeCkpKQotKGRlZmluZS1zZXhwLXBh cnNlciBwZWctc3VmZml4IGFsbAotICAoYW5kIHBlZy1wcmltYXJ5ICgqIChhbmQgKG9yICIq IiAiKyIgIj8iKSBwZWctc3ApKSkpCi0oZGVmaW5lLXNleHAtcGFyc2VyIHBlZy1wcmltYXJ5 IGFsbAotICAob3IgKGFuZCAiKCIgcGVnLXNwIHBlZy1wYXR0ZXJuICIpIiBwZWctc3ApCi0g ICAgICAoYW5kICIuIiBwZWctc3ApCi0gICAgICBwZWctbGl0ZXJhbAotICAgICAgcGVnLWNo YXJjbGFzcwotICAgICAgKGFuZCBwZWctbm9udGVybWluYWwgKG5vdC1mb2xsb3dlZC1ieSAi PCIpKSkpCi0oZGVmaW5lLXNleHAtcGFyc2VyIHBlZy1saXRlcmFsIGFsbAotICAoYW5kICIn IiAoKiAoYW5kIChub3QtZm9sbG93ZWQtYnkgIiciKSBwZWctYW55KSkgIiciIHBlZy1zcCkp Ci0oZGVmaW5lLXNleHAtcGFyc2VyIHBlZy1jaGFyY2xhc3MgYWxsCi0gIChhbmQgKGlnbm9y ZSAiWyIpCi0gICAgICAgKCogKGFuZCAobm90LWZvbGxvd2VkLWJ5ICJdIikKLSAgICAgICAg ICAgICAgIChvciBjaGFyY2xhc3MtcmFuZ2UgY2hhcmNsYXNzLXNpbmdsZSkpKQotICAgICAg IChpZ25vcmUgIl0iKQotICAgICAgIHBlZy1zcCkpCi0oZGVmaW5lLXNleHAtcGFyc2VyIGNo YXJjbGFzcy1yYW5nZSBhbGwgKGFuZCBwZWctYW55ICItIiBwZWctYW55KSkKLShkZWZpbmUt c2V4cC1wYXJzZXIgY2hhcmNsYXNzLXNpbmdsZSBhbGwgcGVnLWFueSkKLShkZWZpbmUtc2V4 cC1wYXJzZXIgcGVnLW5vbnRlcm1pbmFsIGFsbAotICAoYW5kICgrIChvciAocmFuZ2UgI1xh ICNceikgKHJhbmdlICNcQSAjXFopIChyYW5nZSAjXDAgI1w5KSAiLSIpKSBwZWctc3ApKQot KGRlZmluZS1zZXhwLXBhcnNlciBwZWctc3Agbm9uZQotICAoKiAob3IgIiAiICJcdCIgIlxu IikpKQorKGRlZmluZS1zZXhwLXBhcnNlciBHcmFtbWFyIGFsbAorICAoYW5kIFNwYWNpbmcg KCsgRGVmaW5pdGlvbikgRW5kT2ZGaWxlKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgRGVmaW5p dGlvbiBhbGwKKyAgKGFuZCBJZGVudGlmaWVyIExFRlRBUlJPVyBFeHByZXNzaW9uKSkKKyhk ZWZpbmUtc2V4cC1wYXJzZXIgRXhwcmVzc2lvbiBhbGwKKyAgKGFuZCBTZXF1ZW5jZSAoKiAo YW5kIFNMQVNIIFNlcXVlbmNlKSkpKQorKGRlZmluZS1zZXhwLXBhcnNlciBTZXF1ZW5jZSBh bGwKKyAgKCogUHJlZml4KSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgUHJlZml4IGFsbAorICAo YW5kICg/IChvciBBTkQgTk9UKSkgU3VmZml4KSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgU3Vm Zml4IGFsbAorICAoYW5kIFByaW1hcnkgKD8gKG9yIFFVRVNUSU9OIFNUQVIgUExVUykpKSkK KyhkZWZpbmUtc2V4cC1wYXJzZXIgUHJpbWFyeSBhbGwKKyAgKG9yIChhbmQgSWRlbnRpZmll ciAobm90LWZvbGxvd2VkLWJ5IExFRlRBUlJPVykpCisgICAgICAoYW5kIE9QRU4gRXhwcmVz c2lvbiBDTE9TRSkKKyAgICAgIExpdGVyYWwKKyAgICAgIENsYXNzCisgICAgICBET1QpKQor KGRlZmluZS1zZXhwLXBhcnNlciBJZGVudGlmaWVyIGFsbAorICAoYW5kIElkZW50U3RhcnQg KCogSWRlbnRDb250KSBTcGFjaW5nKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgSWRlbnRTdGFy dCBib2R5CisgIChvciAob3IgKHJhbmdlICNcYSAjXHopIChyYW5nZSAjXEEgI1xaKSAiXyIp ICItIikpIDsgTk9URTogLSBpcyBhbiBleHRlbnNpb24KKyhkZWZpbmUtc2V4cC1wYXJzZXIg SWRlbnRDb250IGJvZHkKKyAgKG9yIElkZW50U3RhcnQgKHJhbmdlICNcMCAjXDkpKSkKKyhk ZWZpbmUtc2V4cC1wYXJzZXIgTGl0ZXJhbCBhbGwKKyAgKG9yIChhbmQgU1FVT1RFICgqIChh bmQgKG5vdC1mb2xsb3dlZC1ieSBTUVVPVEUpIENoYXIpKSBTUVVPVEUgU3BhY2luZykKKyAg ICAgIChhbmQgRFFVT1RFICgqIChhbmQgKG5vdC1mb2xsb3dlZC1ieSBEUVVPVEUpIENoYXIp KSBEUVVPVEUgU3BhY2luZykpKQorKGRlZmluZS1zZXhwLXBhcnNlciBDbGFzcyBhbGwKKyAg KGFuZCBPUEVOQlJBQ0tFVCAoKiAoYW5kIChub3QtZm9sbG93ZWQtYnkgQ0xPU0VCUkFDS0VU KSBSYW5nZSkpIENMT1NFQlJBQ0tFVCBTcGFjaW5nKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIg UmFuZ2UgYWxsCisgIChvciAoYW5kIENoYXIgREFTSCBDaGFyKSBDaGFyKSkKKyhkZWZpbmUt c2V4cC1wYXJzZXIgQ2hhciBhbGwKKyAgKG9yIChhbmQgIlxcIiAob3IgIm4iICJyIiAidCIg ImYiICInIiAiXCIiICJbIiAiXSIgIlxcIikpCisgICAgICAoYW5kICJcXCIgKHJhbmdlICNc MCAjXDcpIChyYW5nZSAjXDAgI1w3KSAocmFuZ2UgI1wwICNcNykpCisgICAgICAoYW5kICJc XCIgKHJhbmdlICNcMCAjXDcpICg/IChyYW5nZSAjXDAgI1w3KSkpCisgICAgICAoYW5kICJc XCIgInUiIEhFWCBIRVggSEVYIEhFWCkKKyAgICAgIChhbmQgKG5vdC1mb2xsb3dlZC1ieSAi XFwiKSBwZWctYW55KSkpCisoZGVmaW5lLXNleHAtcGFyc2VyIExFRlRBUlJPVyBib2R5Cisg IChhbmQgKG9yICI8LS0iICI8LSIgIjwiKSBTcGFjaW5nKSkgOyBOT1RFOiA8LS0gYW5kIDwg YXJlIGV4dGVuc2lvbnMKKyhkZWZpbmUtc2V4cC1wYXJzZXIgSEVYIGJvZHkKKyAgKG9yIChy YW5nZSAjXDAgI1w5KSAocmFuZ2UgI1xhICNcZikgKHJhbmdlICNcQSAjXEYpKSkKKyhkZWZp bmUtc2V4cC1wYXJzZXIgU0xBU0ggbm9uZQorICAoYW5kICIvIiBTcGFjaW5nKSkKKyhkZWZp bmUtc2V4cC1wYXJzZXIgQU5EIGFsbAorICAoYW5kICImIiBTcGFjaW5nKSkKKyhkZWZpbmUt c2V4cC1wYXJzZXIgTk9UIGFsbAorICAoYW5kICIhIiBTcGFjaW5nKSkKKyhkZWZpbmUtc2V4 cC1wYXJzZXIgUVVFU1RJT04gYWxsCisgIChhbmQgIj8iIFNwYWNpbmcpKQorKGRlZmluZS1z ZXhwLXBhcnNlciBTVEFSIGFsbAorICAoYW5kICIqIiBTcGFjaW5nKSkKKyhkZWZpbmUtc2V4 cC1wYXJzZXIgUExVUyBhbGwKKyAgKGFuZCAiKyIgU3BhY2luZykpCisoZGVmaW5lLXNleHAt cGFyc2VyIE9QRU4gbm9uZQorICAoYW5kICIoIiBTcGFjaW5nKSkKKyhkZWZpbmUtc2V4cC1w YXJzZXIgQ0xPU0Ugbm9uZQorICAoYW5kICIpIiBTcGFjaW5nKSkKKyhkZWZpbmUtc2V4cC1w YXJzZXIgRE9UIGFsbAorICAoYW5kICIuIiBTcGFjaW5nKSkKKyhkZWZpbmUtc2V4cC1wYXJz ZXIgU1FVT1RFIG5vbmUgIiciKQorKGRlZmluZS1zZXhwLXBhcnNlciBEUVVPVEUgbm9uZSAi XCIiKQorKGRlZmluZS1zZXhwLXBhcnNlciBPUEVOQlJBQ0tFVCBub25lICJbIikKKyhkZWZp bmUtc2V4cC1wYXJzZXIgQ0xPU0VCUkFDS0VUIG5vbmUgIl0iKQorKGRlZmluZS1zZXhwLXBh cnNlciBEQVNIIG5vbmUgIi0iKQorKGRlZmluZS1zZXhwLXBhcnNlciBTcGFjaW5nIG5vbmUK KyAgKCogKG9yIFNwYWNlIENvbW1lbnQpKSkKKyhkZWZpbmUtc2V4cC1wYXJzZXIgQ29tbWVu dCBub25lCisgIChhbmQgIiMiICgqIChhbmQgKG5vdC1mb2xsb3dlZC1ieSBFbmRPZkxpbmUp IHBlZy1hbnkpKSBFbmRPZkxpbmUpKQorKGRlZmluZS1zZXhwLXBhcnNlciBTcGFjZSBub25l CisgIChvciAiICIgIlx0IiBFbmRPZkxpbmUpKQorKGRlZmluZS1zZXhwLXBhcnNlciBFbmRP ZkxpbmUgbm9uZQorICAob3IgIlxyXG4iICJcbiIgIlxyIikpCisoZGVmaW5lLXNleHAtcGFy c2VyIEVuZE9mRmlsZSBub25lCisgIChub3QtZm9sbG93ZWQtYnkgcGVnLWFueSkpCisKIAog Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7 Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsKIDs7Ozs7IFBBUlNFIFNUUklORyBQRUdTCkBA IC0xMDEsNyArMTkxLDcgQEAgUkIgPCAnXScKIDs7IHdpbGwgZGVmaW5lIGFsbCBvZiB0aGUg bm9udGVybWluYWxzIGluIHRoZSBncmFtbWFyIHdpdGggZXF1aXZhbGVudAogOzsgUEVHIHMt ZXhwcmVzc2lvbnMuCiAoZGVmaW5lIChwZWctcGFyc2VyIHN0ciBmb3Itc3ludGF4KQotICAo bGV0ICgocGFyc2VkIChtYXRjaC1wYXR0ZXJuIHBlZy1ncmFtbWFyIHN0cikpKQorICAobGV0 ICgocGFyc2VkIChtYXRjaC1wYXR0ZXJuIEdyYW1tYXIgc3RyKSkpCiAgICAgKGlmIChub3Qg cGFyc2VkKQogICAgICAgICAoYmVnaW4KICAgICAgICAgICA7OyAoZGlzcGxheSAiSW52YWxp ZCBQRUcgZ3JhbW1hciFcbiIpCkBAIC0xMTAsMTEgKzIwMCwxNjkgQEAgUkIgPCAnXScKICAg ICAgICAgICAoY29uZAogICAgICAgICAgICAoKG9yIChub3QgKGxpc3Q/IGxzdCkpIChudWxs PyBsc3QpKQogICAgICAgICAgICAgbHN0KQotICAgICAgICAgICAoKGVxPyAoY2FyIGxzdCkg J3BlZy1ncmFtbWFyKQotICAgICAgICAgICAgI2AoYmVnaW4KLSAgICAgICAgICAgICAgICAj LEAobWFwIChsYW1iZGEgKHgpIChwZWctbm9udGVybS0+ZGVmbiB4IGZvci1zeW50YXgpKQot ICAgICAgICAgICAgICAgICAgICAgICAgKGNvbnRleHQtZmxhdHRlbiAobGFtYmRhIChsc3Qp ICg8PSAoZGVwdGggbHN0KSAyKSkKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgKGNkciBsc3QpKSkpKSkpKSkpCisgICAgICAgICAgICgoZXE/IChjYXIgbHN0 KSAnR3JhbW1hcikKKyAgICAgICAgICAgIChHcmFtbWFyLT5kZWZuIGxzdCBmb3Itc3ludGF4 KSkpKSkpKQorCis7OyAoR3JhbW1hciAoRGVmaW5pdGlvbiAuLi4pIChEZWZpbml0aW9uIC4u LikpCisoZGVmaW5lIChHcmFtbWFyLT5kZWZuIGxzdCBmb3Itc3ludGF4KQorICAjYChiZWdp bgorICAgICAgIyxAKG1hcCAobGFtYmRhICh4KSAoRGVmaW5pdGlvbi0+ZGVmbiB4IGZvci1z eW50YXgpKQorICAgICAgICAgICAgICAoY29udGV4dC1mbGF0dGVuIChsYW1iZGEgKGxzdCkg KDw9IChkZXB0aCBsc3QpIDEpKQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChj ZHIgbHN0KSkpKSkKKworOzsgKERlZmluaXRpb24gKElkZW50aWZpZXIgIlNvbWV0aGluZyIp ICI8LSIgKEV4cHJlc3Npb24gLi4uKSkKKzs7ICBgLT4gKGRlZmluZS1wZWctcGF0dGVybiBT b21ldGhpbmcgJ2FsbCAuLi4pCisoZGVmaW5lIChEZWZpbml0aW9uLT5kZWZuIGxzdCBmb3It c3ludGF4KQorICAobWF0Y2ggbHN0CisgICAgKCgnRGVmaW5pdGlvbiAoJ0lkZW50aWZpZXIg aWRlbnRpZmllcikgZ3JhYmJlciBleHByZXNzaW9uKQorICAgICAjYChkZWZpbmUtcGVnLXBh dHRlcm4KKyAgICAgICAgICMsKGRhdHVtLT5zeW50YXggZm9yLXN5bnRheCAoc3RyaW5nLT5z eW1ib2wgaWRlbnRpZmllcikpCisgICAgICAgICAjLChtYXRjaCBncmFiYmVyCisgICAgICAg ICAgICAgICAgICAoIjwtLSIgKGRhdHVtLT5zeW50YXggZm9yLXN5bnRheCAnYWxsKSkKKyAg ICAgICAgICAgICAgICAgICgiPC0iICAoZGF0dW0tPnN5bnRheCBmb3Itc3ludGF4ICdib2R5 KSkKKyAgICAgICAgICAgICAgICAgICgiPCIgICAoZGF0dW0tPnN5bnRheCBmb3Itc3ludGF4 ICdub25lKSkpCisgICAgICAgICAjLChjb21wcmVzc29yCisgICAgICAgICAgICAgKEV4cHJl c3Npb24tPmRlZm4gZXhwcmVzc2lvbiBmb3Itc3ludGF4KQorICAgICAgICAgICAgIGZvci1z eW50YXgpKSkpKQorCis7OyAoRXhwcmVzc2lvbiBYKQorOzsgIGAtPiAob3IgWCkKKzs7IChF eHByZXNzaW9uIFggWSkKKzs7ICBgLT4gKG9yIFggWSkKKzs7IChFeHByZXNzaW9uIFggKFkg WiAuLi4pKQorOzsgIGAtPiAob3IgWCBZIFogLi4uKQorKGRlZmluZSAoRXhwcmVzc2lvbi0+ ZGVmbiBsc3QgZm9yLXN5bnRheCkKKyAgKG1hdGNoIGxzdAorICAgICgoJ0V4cHJlc3Npb24g c2VxIC4uLikKKyAgICAgI2Aob3IgIyxAKG1hcCAobGFtYmRhICh4KSAoU2VxdWVuY2UtPmRl Zm4geCBmb3Itc3ludGF4KSkKKyAgICAgICAgICAgICAgICAgICAoa2V5d29yZC1mbGF0dGVu ICcoU2VxdWVuY2UpIHNlcSkpKSkpKQorCis7OyAoU2VxdWVuY2UgWCkKKzs7ICBgLT4gKGFu ZCBYKQorOzsgKFNlcXVlbmNlIFggWSkKKzs7ICBgLT4gKGFuZCBYIFkpCis7OyAoU2VxdWVu Y2UgWCAoWSBaIC4uLikpCis7OyAgYC0+IChhbmQgWCBZIFogLi4uKQorKGRlZmluZSAoU2Vx dWVuY2UtPmRlZm4gbHN0IGZvci1zeW50YXgpCisgIChtYXRjaCBsc3QKKyAgICAoKCdTZXF1 ZW5jZSBwcmUgLi4uKQorICAgICAjYChhbmQgIyxAKG1hcCAobGFtYmRhICh4KSAoUHJlZml4 LT5kZWZuIHggZm9yLXN5bnRheCkpCisgICAgICAgICAgICAgICAgICAgIChrZXl3b3JkLWZs YXR0ZW4gJyhQcmVmaXgpIHByZSkpKSkpKQorCis7OyAoUHJlZml4IChTdWZmaXggLi4uKSkK Kzs7ICBgLT4gKC4uLikKKzs7IChQcmVmaXggKE5PVCAiISIpIChTdWZmaXggLi4uKSkKKzs7 ICBgLT4gKG5vdC1mb2xsb3dlZC1ieSAuLi4pCis7OyAoUHJlZml4IChBTkQgIiYiKSAoU3Vm Zml4IC4uLikpCis7OyAgYC0+IChmb2xsb3dlZC1ieSAuLi4pCisoZGVmaW5lIChQcmVmaXgt PmRlZm4gbHN0IGZvci1zeW50YXgpCisgIChtYXRjaCBsc3QKKyAgICAoKCdQcmVmaXggKCdB TkQgXykgc3UpICNgKGZvbGxvd2VkLWJ5ICAgICAjLChTdWZmaXgtPmRlZm4gc3UgZm9yLXN5 bnRheCkpKQorICAgICgoJ1ByZWZpeCAoJ05PVCBfKSBzdSkgI2Aobm90LWZvbGxvd2VkLWJ5 ICMsKFN1ZmZpeC0+ZGVmbiBzdSBmb3Itc3ludGF4KSkpCisgICAgKCgnUHJlZml4IHN1ZmZp eCkgKFN1ZmZpeC0+ZGVmbiBzdWZmaXggZm9yLXN5bnRheCkpKSkKKworOzsgKFN1ZmZpeCAo UHJpbWFyeSAuLi4pKQorOzsgIGAtPiAoLi4uKQorOzsgKFN1ZmZpeCAoUHJpbWFyeSAuLi4p IChTVEFSICIqIikpCis7OyAgYC0+ICgqIC4uLikKKzs7IChTdWZmaXggKFByaW1hcnkgLi4u KSAoUVVFU1RJT04gIj8iKSkKKzs7ICBgLT4gKD8gLi4uKQorOzsgKFN1ZmZpeCAoUHJpbWFy eSAuLi4pIChQTFVTICIrIikpCis7OyAgYC0+ICgrIC4uLikKKyhkZWZpbmUgKFN1ZmZpeC0+ ZGVmbiBsc3QgZm9yLXN5bnRheCkKKyAgKG1hdGNoIGxzdAorICAgICgoJ1N1ZmZpeCBwcmlt KSAgICAgICAgICAgICAgIChQcmltYXJ5LT5kZWZuIHByaW0gZm9yLXN5bnRheCkpCisgICAg KCgnU3VmZml4IHByaW0gKCdTVEFSICAgICBfKSkgI2AoKiAjLChQcmltYXJ5LT5kZWZuIHBy aW0gZm9yLXN5bnRheCkpKQorICAgICgoJ1N1ZmZpeCBwcmltICgnUVVFU1RJT04gXykpICNg KD8gIywoUHJpbWFyeS0+ZGVmbiBwcmltIGZvci1zeW50YXgpKSkKKyAgICAoKCdTdWZmaXgg cHJpbSAoJ1BMVVMgICAgIF8pKSAjYCgrICMsKFByaW1hcnktPmRlZm4gcHJpbSBmb3Itc3lu dGF4KSkpKSkKKworCisoZGVmaW5lIChQcmltYXJ5LT5kZWZuIGxzdCBmb3Itc3ludGF4KQor ICAobGV0ICgodmFsdWUgKHNlY29uZCBsc3QpKSkKKyAgICAobWF0Y2ggKGNhciB2YWx1ZSkK KyAgICAgICgnRE9UICAgICAgICAjJ3BlZy1hbnkpCisgICAgICAoJ0lkZW50aWZpZXIgKElk ZW50aWZpZXItPmRlZm4gdmFsdWUgZm9yLXN5bnRheCkpCisgICAgICAoJ0V4cHJlc3Npb24g KEV4cHJlc3Npb24tPmRlZm4gdmFsdWUgZm9yLXN5bnRheCkpCisgICAgICAoJ0xpdGVyYWwg ICAgKExpdGVyYWwtPmRlZm4gdmFsdWUgZm9yLXN5bnRheCkpCisgICAgICAoJ0NsYXNzICAg ICAgKENsYXNzLT5kZWZuIHZhbHVlIGZvci1zeW50YXgpKSkpKQorCis7OyAoSWRlbnRpZmll ciAiaGVsbG8iKQorOzsgIGAtPiBoZWxsbworKGRlZmluZSAoSWRlbnRpZmllci0+ZGVmbiBs c3QgZm9yLXN5bnRheCkKKyAgKGRhdHVtLT5zeW50YXggZm9yLXN5bnRheCAoc3RyaW5nLT5z eW1ib2wgKHNlY29uZCBsc3QpKSkpCisKKzs7IChMaXRlcmFsIChDaGFyICJhIikgKENoYXIg ImIiKSAoQ2hhciAiYyIpKQorOzsgIGAtPiAiYWJjIgorKGRlZmluZSAoTGl0ZXJhbC0+ZGVm biBsc3QgZm9yLXN5bnRheCkKKyAgKGFwcGx5IHN0cmluZyAobWFwIChsYW1iZGEgKHgpIChD aGFyLT5kZWZuIHggZm9yLXN5bnRheCkpIChjZHIgbHN0KSkpKQorCis7OyBUT0RPOiBlbXB0 eSBDbGFzcyBjYW4gaGFwcGVuOiBgW11gLCBidXQgd2hhdCBkb2VzIGl0IHJlcHJlc2VudD8K Kzs7IChDbGFzcyAuLi4pCis7OyAgYC0+IChvciAuLi4pCisoZGVmaW5lIChDbGFzcy0+ZGVm biBsc3QgZm9yLXN5bnRheCkKKyAgI2Aob3IgIyxAKG1hcCAobGFtYmRhICh4KSAoUmFuZ2Ut PmRlZm4geCBmb3Itc3ludGF4KSkKKyAgICAgICAgICAgICAgICAoY2RyIGxzdCkpKSkKKwor OzsgRm9yIG9uZSBjaGFyYWN0ZXI6Cis7OyAoUmFuZ2UgKENoYXIgImEiKSkKKzs7ICBgLT4g ImEiCis7OyBPciBmb3IgYSByYW5nZToKKzs7IChSYW5nZSAoQ2hhciAiYSIpIChDaGFyICJi IikpCis7OyAgYC0+IChyYW5nZSAjXGEgI1xiKQorKGRlZmluZSAoUmFuZ2UtPmRlZm4gbHN0 IGZvci1zeW50YXgpCisgIChtYXRjaCBsc3QKKyAgICAoKCdSYW5nZSBjaCkKKyAgICAgKHN0 cmluZyAoQ2hhci0+ZGVmbiBjaCBmb3Itc3ludGF4KSkpCisgICAgKCgnUmFuZ2UgcmFuZ2Ut YmVnaW5uaW5nIHJhbmdlLWVuZCkKKyAgICAgI2AocmFuZ2UKKyAgICAgICAgICMsKENoYXIt PmRlZm4gcmFuZ2UtYmVnaW5uaW5nIGZvci1zeW50YXgpCisgICAgICAgICAjLChDaGFyLT5k ZWZuIHJhbmdlLWVuZCAgICAgICBmb3Itc3ludGF4KSkpKSkKKworOzsgKENoYXIgImEiKQor OzsgIGAtPiAjXGEKKzs7IChDaGFyICJcXG4iKQorOzsgIGAtPiAjXG5ld2xpbmUKKzs7IChD aGFyICJcXDEzNSIpCis7OyAgYC0+ICNcXQorKGRlZmluZSAoQ2hhci0+ZGVmbiBsc3QgZm9y LXN5bnRheCkKKyAgKGxldCogKChjaGFyc3RyIChzZWNvbmQgbHN0KSkKKyAgICAgICAgIChm aXJzdCAgIChzdHJpbmctcmVmIGNoYXJzdHIgMCkpKQorICAgIChjb25kCisgICAgICAoKD0g MSAoc3RyaW5nLWxlbmd0aCBjaGFyc3RyKSkgZmlyc3QpCisgICAgICAoKGNoYXItbnVtZXJp Yz8gKHN0cmluZy1yZWYgY2hhcnN0ciAxKSkKKyAgICAgICAoaW50ZWdlci0+Y2hhcgorICAg ICAgICAgKHJlZHVjZSArIDAKKyAgICAgICAgICAgICAgICAgKG1hcAorICAgICAgICAgICAg ICAgICAgIChsYW1iZGEgKHggeSkKKyAgICAgICAgICAgICAgICAgICAgICgqICgtIChjaGFy LT5pbnRlZ2VyIHgpIChjaGFyLT5pbnRlZ2VyICNcMCkpIHkpKQorICAgICAgICAgICAgICAg ICAgIChyZXZlcnNlIChzdHJpbmctPmxpc3QgY2hhcnN0ciAxKSkKKyAgICAgICAgICAgICAg ICAgICAnKDEgOCA2NCkpKSkpCisgICAgICAoKGNoYXI9PyAjXHUgKHN0cmluZy1yZWYgY2hh cnN0ciAxKSkKKyAgICAgICAoaW50ZWdlci0+Y2hhcgorICAgICAgICAgKHJlZHVjZSArIDAK KyAgICAgICAgICAgICAgICAgKG1hcAorICAgICAgICAgICAgICAgICAgIChsYW1iZGEgKHgg eSkKKyAgICAgICAgICAgICAgICAgICAgICgqIChjb25kCisgICAgICAgICAgICAgICAgICAg ICAgICAgICgoY2hhci1udW1lcmljPyB4KQorICAgICAgICAgICAgICAgICAgICAgICAgICAg KC0gKGNoYXItPmludGVnZXIgeCkgKGNoYXItPmludGVnZXIgI1wwKSkpCisgICAgICAgICAg ICAgICAgICAgICAgICAgICgoY2hhci1hbHBoYWJldGljPyB4KQorICAgICAgICAgICAgICAg ICAgICAgICAgICAgKCsgMTAgKC0gKGNoYXItPmludGVnZXIgeCkgKGNoYXItPmludGVnZXIg I1xhKSkpKSkKKyAgICAgICAgICAgICAgICAgICAgICAgIHkpKQorICAgICAgICAgICAgICAg ICAgIChyZXZlcnNlIChzdHJpbmctPmxpc3QgKHN0cmluZy1kb3duY2FzZSBjaGFyc3RyKSAy KSkKKyAgICAgICAgICAgICAgICAgICAnKDEgMTYgMjU2IDQwOTYpKSkpKQorICAgICAgKGVs c2UKKyAgICAgICAgKGNhc2UgKHN0cmluZy1yZWYgY2hhcnN0ciAxKQorICAgICAgICAgICgo I1xuKSAjXG5ld2xpbmUpCisgICAgICAgICAgKCgjXHIpICNccmV0dXJuKQorICAgICAgICAg ICgoI1x0KSAjXHRhYikKKyAgICAgICAgICAoKCNcZikgI1xwYWdlKQorICAgICAgICAgICgo I1wnKSAjXCcpCisgICAgICAgICAgKCgjXCIpICNcIikKKyAgICAgICAgICAoKCNcXSkgI1xd KQorICAgICAgICAgICgoI1xcKSAjXFwpCisgICAgICAgICAgKCgjXFspICNcWykpKSkpKQor CisoZGVmaW5lIHBlZy1ncmFtbWFyIEdyYW1tYXIpCiAKIDs7IE1hY3JvIHdyYXBwZXIgZm9y IFBFRy1QQVJTRVIuICBQYXJzZXMgUEVHIGdyYW1tYXJzIGV4cHJlc3NlZCBhcyBzdHJpbmdz IGFuZAogOzsgZGVmaW5lcyBhbGwgdGhlIGFwcHJvcHJpYXRlIG5vbnRlcm1pbmFscy4KQEAg LTEyNCwxMTkgKzM3Miw2IEBAIFJCIDwgJ10nCiAgICAgICAoKF8gc3RyKQogICAgICAgIChw ZWctcGFyc2VyIChzeW50YXgtPmRhdHVtICMnc3RyKSB4KSkpKSkKIAotOzsgbHN0IGhhcyBm b3JtYXQgKG5vbnRlcm0gZ3JhYmJlciBwYXR0ZXJuKSwgd2hlcmUKLTs7ICAgbm9udGVybSBp cyBhIHN5bWJvbCAodGhlIG5hbWUgb2YgdGhlIG5vbnRlcm1pbmFsKSwKLTs7ICAgZ3JhYmJl ciBpcyBhIHN0cmluZyAoZWl0aGVyICI8IiwgIjwtIiBvciAiPC0tIiksIGFuZAotOzsgICBw YXR0ZXJuIGlzIHRoZSBwYXJzZSBvZiBhIFBFRyBwYXR0ZXJuIGV4cHJlc3NlZCBhcyBhcyBz dHJpbmcuCi0oZGVmaW5lIChwZWctbm9udGVybS0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKLSAg KGxldCogKChub250ZXJtIChjYXIgbHN0KSkKLSAgICAgICAgIChncmFiYmVyIChjYWRyIGxz dCkpCi0gICAgICAgICAocGF0dGVybiAoY2FkZHIgbHN0KSkKLSAgICAgICAgIChub250ZXJt LW5hbWUgKGRhdHVtLT5zeW50YXggZm9yLXN5bnRheAotICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAoc3RyaW5nLT5zeW1ib2wgKGNhZHIgbm9udGVybSkpKSkpCi0g ICAgI2AoZGVmaW5lLXBlZy1wYXR0ZXJuICMsbm9udGVybS1uYW1lCi0gICAgICAgIywoY29u ZAotICAgICAgICAgICgoc3RyaW5nPT8gZ3JhYmJlciAiPC0tIikgKGRhdHVtLT5zeW50YXgg Zm9yLXN5bnRheCAnYWxsKSkKLSAgICAgICAgICAoKHN0cmluZz0/IGdyYWJiZXIgIjwtIikg KGRhdHVtLT5zeW50YXggZm9yLXN5bnRheCAnYm9keSkpCi0gICAgICAgICAgKGVsc2UgKGRh dHVtLT5zeW50YXggZm9yLXN5bnRheCAnbm9uZSkpKQotICAgICAgICMsKGNvbXByZXNzb3Ig KHBlZy1wYXR0ZXJuLT5kZWZuIHBhdHRlcm4gZm9yLXN5bnRheCkgZm9yLXN5bnRheCkpKSkK LQotOzsgbHN0IGhhcyBmb3JtYXQgKCdwZWctcGF0dGVybiAuLi4pLgotOzsgQWZ0ZXIgdGhl IGNvbnRleHQtZmxhdHRlbiwgKGNkciBsc3QpIGhhcyBmb3JtYXQKLTs7ICAgKCgncGVnLWFs dGVybmF0aXZlIC4uLikgLi4uKSwgd2hlcmUgdGhlIG91dGVyIGxpc3QgaXMgYSBjb2xsZWN0 aW9uCi07OyAgIG9mIGVsZW1lbnRzIGZyb20gYSAnLycgYWx0ZXJuYXRpdmUuCi0oZGVmaW5l IChwZWctcGF0dGVybi0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKLSAgI2Aob3IgIyxAKG1hcCAo bGFtYmRhICh4KSAocGVnLWFsdGVybmF0aXZlLT5kZWZuIHggZm9yLXN5bnRheCkpCi0gICAg ICAgICAgICAgICAgKGNvbnRleHQtZmxhdHRlbiAobGFtYmRhICh4KSAoZXE/IChjYXIgeCkg J3BlZy1hbHRlcm5hdGl2ZSkpCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAo Y2RyIGxzdCkpKSkpCi0KLTs7IGxzdCBoYXMgZm9ybWF0ICgncGVnLWFsdGVybmF0aXZlIC4u LikuCi07OyBBZnRlciB0aGUgY29udGV4dC1mbGF0dGVuLCAoY2RyIGxzdCkgaGFzIHRoZSBm b3JtYXQKLTs7ICAgKGl0ZW0gLi4uKSwgd2hlcmUgZWFjaCBpdGVtIGhhcyBmb3JtYXQgZWl0 aGVyICgiISIgLi4uKSwgKCImIiAuLi4pLAotOzsgICBvciAoJ3BlZy1zdWZmaXggLi4uKS4K LShkZWZpbmUgKHBlZy1hbHRlcm5hdGl2ZS0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKLSAgI2Ao YW5kICMsQChtYXAgKGxhbWJkYSAoeCkgKHBlZy1ib2R5LT5kZWZuIHggZm9yLXN5bnRheCkp Ci0gICAgICAgICAgICAgICAgIChjb250ZXh0LWZsYXR0ZW4gKGxhbWJkYSAoeCkgKG9yIChz dHJpbmc/IChjYXIgeCkpCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAoZXE/IChjYXIgeCkgJ3BlZy1zdWZmaXgpKSkKLSAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAoY2RyIGxzdCkpKSkpCi0KLTs7IGxzdCBoYXMgdGhlIGZvcm1h dCBlaXRoZXIKLTs7ICAgKCIhIiAoJ3BlZy1zdWZmaXggLi4uKSksICgiJiIgKCdwZWctc3Vm Zml4IC4uLikpLCBvcgotOzsgICAgICgncGVnLXN1ZmZpeCAuLi4pLgotKGRlZmluZSAocGVn LWJvZHktPmRlZm4gbHN0IGZvci1zeW50YXgpCi0gICAgKGNvbmQKLSAgICAgICgoZXF1YWw/ IChjYXIgbHN0KSAiJiIpCi0gICAgICAgI2AoZm9sbG93ZWQtYnkgIywocGVnLXN1ZmZpeC0+ ZGVmbiAoY2FkciBsc3QpIGZvci1zeW50YXgpKSkKLSAgICAgICgoZXF1YWw/IChjYXIgbHN0 KSAiISIpCi0gICAgICAgI2Aobm90LWZvbGxvd2VkLWJ5ICMsKHBlZy1zdWZmaXgtPmRlZm4g KGNhZHIgbHN0KSBmb3Itc3ludGF4KSkpCi0gICAgICAoKGVxPyAoY2FyIGxzdCkgJ3BlZy1z dWZmaXgpCi0gICAgICAgKHBlZy1zdWZmaXgtPmRlZm4gbHN0IGZvci1zeW50YXgpKQotICAg ICAgKGVsc2UgYChwZWctcGFyc2UtYm9keS1mYWlsICxsc3QpKSkpCi0KLTs7IGxzdCBoYXMg Zm9ybWF0ICgncGVnLXN1ZmZpeCA8cGVnLXByaW1hcnk+ICg/ICgvICIqIiAiPyIgIisiKSkp Ci0oZGVmaW5lIChwZWctc3VmZml4LT5kZWZuIGxzdCBmb3Itc3ludGF4KQotICAobGV0ICgo aW5uZXItZGVmbiAocGVnLXByaW1hcnktPmRlZm4gKGNhZHIgbHN0KSBmb3Itc3ludGF4KSkp Ci0gICAgKGNvbmQKLSAgICAgICgobnVsbD8gKGNkZHIgbHN0KSkKLSAgICAgICBpbm5lci1k ZWZuKQotICAgICAgKChlcXVhbD8gKGNhZGRyIGxzdCkgIioiKQotICAgICAgICNgKCogIyxp bm5lci1kZWZuKSkKLSAgICAgICgoZXF1YWw/IChjYWRkciBsc3QpICI/IikKLSAgICAgICAj YCg/ICMsaW5uZXItZGVmbikpCi0gICAgICAoKGVxdWFsPyAoY2FkZHIgbHN0KSAiKyIpCi0g ICAgICAgI2AoKyAjLGlubmVyLWRlZm4pKSkpKQotCi07OyBQYXJzZSBhIHByaW1hcnkuCi0o ZGVmaW5lIChwZWctcHJpbWFyeS0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKLSAgKGxldCAoKGVs IChjYWRyIGxzdCkpKQotICAoY29uZAotICAgKChsaXN0PyBlbCkKLSAgICAoY29uZAotICAg ICAoKGVxPyAoY2FyIGVsKSAncGVnLWxpdGVyYWwpCi0gICAgICAocGVnLWxpdGVyYWwtPmRl Zm4gZWwgZm9yLXN5bnRheCkpCi0gICAgICgoZXE/IChjYXIgZWwpICdwZWctY2hhcmNsYXNz KQotICAgICAgKHBlZy1jaGFyY2xhc3MtPmRlZm4gZWwgZm9yLXN5bnRheCkpCi0gICAgICgo ZXE/IChjYXIgZWwpICdwZWctbm9udGVybWluYWwpCi0gICAgICAoZGF0dW0tPnN5bnRheCBm b3Itc3ludGF4IChzdHJpbmctPnN5bWJvbCAoY2FkciBlbCkpKSkpKQotICAgKChzdHJpbmc/ IGVsKQotICAgIChjb25kCi0gICAgICgoZXF1YWw/IGVsICIoIikKLSAgICAgIChwZWctcGF0 dGVybi0+ZGVmbiAoY2FkZHIgbHN0KSBmb3Itc3ludGF4KSkKLSAgICAgKChlcXVhbD8gZWwg Ii4iKQotICAgICAgKGRhdHVtLT5zeW50YXggZm9yLXN5bnRheCAncGVnLWFueSkpCi0gICAg IChlbHNlIChkYXR1bS0+c3ludGF4IGZvci1zeW50YXgKLSAgICAgICAgICAgICAgICAgICAg ICAgICAgYChwZWctcGFyc2UtYW55IHVua25vd24tc3RyaW5nICxsc3QpKSkpKQotICAgKGVs c2UgKGRhdHVtLT5zeW50YXggZm9yLXN5bnRheAotICAgICAgICAgICAgICAgICAgICAgICAg YChwZWctcGFyc2UtYW55IHVua25vd24tZWwgLGxzdCkpKSkpKQotCi07OyBUcmltcyBjaGFy YWN0ZXJzIG9mZiB0aGUgZnJvbnQgYW5kIGVuZCBvZiBTVFIuCi07OyAodHJpbS0xY2hhcnMg IidhYiciKSAtPiAiYWIiCi0oZGVmaW5lICh0cmltLTFjaGFycyBzdHIpIChzdWJzdHJpbmcg c3RyIDEgKC0gKHN0cmluZy1sZW5ndGggc3RyKSAxKSkpCi0KLTs7IFBhcnNlcyBhIGxpdGVy YWwuCi0oZGVmaW5lIChwZWctbGl0ZXJhbC0+ZGVmbiBsc3QgZm9yLXN5bnRheCkKLSAgKGRh dHVtLT5zeW50YXggZm9yLXN5bnRheCAodHJpbS0xY2hhcnMgKGNhZHIgbHN0KSkpKQotCi07 OyBQYXJzZXMgYSBjaGFyY2xhc3MuCi0oZGVmaW5lIChwZWctY2hhcmNsYXNzLT5kZWZuIGxz dCBmb3Itc3ludGF4KQotICAjYChvcgotICAgICAjLEAobWFwCi0gICAgICAgICAobGFtYmRh IChjYykKLSAgICAgICAgICAgKGNvbmQKLSAgICAgICAgICAgICgoZXE/IChjYXIgY2MpICdj aGFyY2xhc3MtcmFuZ2UpCi0gICAgICAgICAgICAgI2AocmFuZ2UgIywoZGF0dW0tPnN5bnRh eAotICAgICAgICAgICAgICAgICAgICAgICAgIGZvci1zeW50YXgKLSAgICAgICAgICAgICAg ICAgICAgICAgICAoc3RyaW5nLXJlZiAoY2FkciBjYykgMCkpCi0gICAgICAgICAgICAgICAg ICAgICAgIywoZGF0dW0tPnN5bnRheAotICAgICAgICAgICAgICAgICAgICAgICAgIGZvci1z eW50YXgKLSAgICAgICAgICAgICAgICAgICAgICAgICAoc3RyaW5nLXJlZiAoY2FkciBjYykg MikpKSkKLSAgICAgICAgICAgICgoZXE/IChjYXIgY2MpICdjaGFyY2xhc3Mtc2luZ2xlKQot ICAgICAgICAgICAgIChkYXR1bS0+c3ludGF4IGZvci1zeW50YXggKGNhZHIgY2MpKSkpKQot ICAgICAgICAgKGNvbnRleHQtZmxhdHRlbgotICAgICAgICAgIChsYW1iZGEgKHgpIChvciAo ZXE/IChjYXIgeCkgJ2NoYXJjbGFzcy1yYW5nZSkKLSAgICAgICAgICAgICAgICAgICAgICAg ICAgKGVxPyAoY2FyIHgpICdjaGFyY2xhc3Mtc2luZ2xlKSkpCi0gICAgICAgICAgKGNkciBs c3QpKSkpKQotCiA7OyBDb21wcmVzc2VzIGEgbGlzdCB0byBzYXZlIHRoZSBvcHRpbWl6ZXIg d29yay4KIDs7IGUuZy4gKG9yIChhbmQgYSkpIC0+IGEKIChkZWZpbmUgKGNvbXByZXNzb3It Y29yZSBsc3QpCkBAIC0yNjMsMTEgKzM5OCwxMCBAQCBSQiA8ICddJwogICAgICAobGV0ICgo c3RyaW5nIChzeW50YXgtPmRhdHVtICMnc3RyLXN0eCkpKQogICAgICAgIChjb21waWxlLXBl Zy1wYXR0ZXJuCiAgICAgICAgIChjb21wcmVzc29yCi0gICAgICAgICAocGVnLXBhdHRlcm4t PmRlZm4KLSAgICAgICAgICAocGVnOnRyZWUgKG1hdGNoLXBhdHRlcm4gcGVnLXBhdHRlcm4g c3RyaW5nKSkgIydzdHItc3R4KQorICAgICAgICAgKEV4cHJlc3Npb24tPmRlZm4KKyAgICAg ICAgICAocGVnOnRyZWUgKG1hdGNoLXBhdHRlcm4gRXhwcmVzc2lvbiBzdHJpbmcpKSAjJ3N0 ci1zdHgpCiAgICAgICAgICAjJ3N0ci1zdHgpCiAgICAgICAgIChpZiAoZXE/IGFjY3VtICdh bGwpICdib2R5IGFjY3VtKSkpKQogICAgICAoZWxzZSAoZXJyb3IgIkJhZCBlbWJlZGRlZCBQ RUcgc3RyaW5nIiBhcmdzKSkpKQogCiAoYWRkLXBlZy1jb21waWxlciEgJ3BlZyBwZWctc3Ry aW5nLWNvbXBpbGUpCi0KZGlmZiAtLWdpdCBhL3Rlc3Qtc3VpdGUvdGVzdHMvcGVnLnRlc3Qg Yi90ZXN0LXN1aXRlL3Rlc3RzL3BlZy50ZXN0CmluZGV4IGY1MTY1NzFlOC4uMTEzNmMwM2Yx IDEwMDY0NAotLS0gYS90ZXN0LXN1aXRlL3Rlc3RzL3BlZy50ZXN0CisrKyBiL3Rlc3Qtc3Vp dGUvdGVzdHMvcGVnLnRlc3QKQEAgLTI4LDE3ICsyOCwyNSBAQAogOzsgdGhlIG5vbnRlcm1p bmFscyBkZWZpbmVkIGluIHRoZSBQRUcgcGFyc2VyIHdyaXR0ZW4gd2l0aAogOzsgUy1leHBy ZXNzaW9ucy4KIChkZWZpbmUgZ3JhbW1hci1tYXBwaW5nCi0gICcoKGdyYW1tYXIgcGVnLWdy YW1tYXIpCi0gICAgKHBhdHRlcm4gcGVnLXBhdHRlcm4pCi0gICAgKGFsdGVybmF0aXZlIHBl Zy1hbHRlcm5hdGl2ZSkKLSAgICAoc3VmZml4IHBlZy1zdWZmaXgpCi0gICAgKHByaW1hcnkg cGVnLXByaW1hcnkpCi0gICAgKGxpdGVyYWwgcGVnLWxpdGVyYWwpCi0gICAgKGNoYXJjbGFz cyBwZWctY2hhcmNsYXNzKQotICAgIChDQ3JhbmdlIGNoYXJjbGFzcy1yYW5nZSkKLSAgICAo Q0NzaW5nbGUgY2hhcmNsYXNzLXNpbmdsZSkKLSAgICAobm9udGVybWluYWwgcGVnLW5vbnRl cm1pbmFsKQotICAgIChzcCBwZWctc3ApKSkKKyAgJygoR3JhbW1hciBHcmFtbWFyKQorICAg IChEZWZpbml0aW9uIERlZmluaXRpb24pCisgICAgKEV4cHJlc3Npb24gRXhwcmVzc2lvbikK KyAgICAoU2VxdWVuY2UgU2VxdWVuY2UpCisgICAgKFByZWZpeCBQcmVmaXgpCisgICAgKFN1 ZmZpeCBTdWZmaXgpCisgICAgKFByaW1hcnkgUHJpbWFyeSkKKyAgICAoSWRlbnRpZmllciBJ ZGVudGlmaWVyKQorICAgIChMaXRlcmFsIExpdGVyYWwpCisgICAgKENsYXNzIENsYXNzKQor ICAgIChSYW5nZSBSYW5nZSkKKyAgICAoQ2hhciBDaGFyKQorICAgIChMRUZUQVJST1cgTEVG VEFSUk9XKQorICAgIChBTkQgQU5EKQorICAgIChOT1QgTk9UKQorICAgIChRVUVTVElPTiBR VUVTVElPTikKKyAgICAoU1RBUiBTVEFSKQorICAgIChQTFVTIFBMVVMpCisgICAgKERPVCBE T1QpKSkKIAogOzsgVHJhbnNmb3JtcyB0aGUgbm9udGVybWluYWxzIGRlZmluZWQgaW4gdGhl IFBFRyBwYXJzZXIgd3JpdHRlbiBhcyBhIFBFRyB0byB0aGUgbm9udGVybWluYWxzIGRlZmlu ZWQgaW4gdGhlIFBFRyBwYXJzZXIgd3JpdHRlbiB3aXRoIFMtZXhwcmVzc2lvbnMuCiAoZGVm aW5lIChncmFtbWFyLXRyYW5zZm9ybSB4KQpAQCAtNjksNyArNzcsNyBAQAogICAgIChwZWc6 dHJlZSAobWF0Y2gtcGF0dGVybiAoQEAgKGljZS05IHBlZykgcGVnLWdyYW1tYXIpIChAQCAo aWNlLTkgcGVnKSBwZWctYXMtcGVnKSkpCiAgICAgKHRyZWUtbWFwCiAgICAgIGdyYW1tYXIt dHJhbnNmb3JtCi0gICAgIChwZWc6dHJlZSAobWF0Y2gtcGF0dGVybiBncmFtbWFyIChAQCAo aWNlLTkgcGVnKSBwZWctYXMtcGVnKSkpKSkpKQorICAgICAocGVnOnRyZWUgKG1hdGNoLXBh dHRlcm4gR3JhbW1hciAoQEAgKGljZS05IHBlZykgcGVnLWFzLXBlZykpKSkpKSkKIAogOzsg QSBncmFtbWFyIGZvciBwYXNjYWwtc3R5bGUgY29tbWVudHMgZnJvbSBXaWtpcGVkaWEuCiAo ZGVmaW5lIGNvbW1lbnQtZ3JhbW1hcgotLSAKMi40Ni4wCgo= --------------Y2zdP01HIvyrhdt0oeLCmvOa-- From debbugs-submit-bounces@debbugs.gnu.org Mon Dec 09 12:23:47 2024 Received: (at 73188-done) by debbugs.gnu.org; 9 Dec 2024 17:23:47 +0000 Received: from localhost ([127.0.0.1]:55435 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tKhU3-0000tz-5A for submit@debbugs.gnu.org; Mon, 09 Dec 2024 12:23:47 -0500 Received: from eggs.gnu.org ([209.51.188.92]:33216) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tKhTx-0000tg-DR for 73188-done@debbugs.gnu.org; Mon, 09 Dec 2024 12:23:45 -0500 Received: from fencepost.gnu.org ([2001:470:142:3::e]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1tKhTr-0005iz-Al; Mon, 09 Dec 2024 12:23:35 -0500 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnu.org; s=fencepost-gnu-org; h=MIME-Version:Date:References:In-Reply-To:Subject:To: From; bh=+oajx4Bw/fEufUscyvgO6GSm6YcqyhawCY0CNsvtIuY=; b=eJGIxhgkdFXpjEb1mron SC3FPEDS2FuLYzYblD5aeAqFSlNSXo0sitwLTgON760Lc2hSkVAUPCrBw/acjCVv8lCHXCW4CrScO LocP3N4Rv5of3wTE+UwSTZ66c19pJEy7Ryvz1AoSmhpkT7RZJ8nLnvOSwuEUDmmIFjFRIxTuvrav6 uiTAtmxnwg3P+YEZnAQGqyAubyZcHkxPN5pB1U+LkTNvPPnSepQtbdTANekm9K0UnbxNVgktO5HIs MdUVFSTk5rjQI9EFvk41Fmo7lZrcbLSclPMkkEV244+7ycoiDBy8xkH3NHlY5OUNb9Pd0ucDnACkn 3/cFPl0afOMIHw==; From: =?utf-8?Q?Ludovic_Court=C3=A8s?= To: Ekaitz Zarraga Subject: Re: bug#73188: PEG parser does not support full PEG grammar In-Reply-To: <57321eb4-962c-4994-b48a-518943b58941@elenq.tech> (Ekaitz Zarraga's message of "Sun, 20 Oct 2024 22:18:52 +0200") References: <78a81bc5-cd0d-0506-185b-c733c66e96ae@elenq.tech> <20240912205751.23724-1-ekaitz@elenq.tech> <87cyk3rbkc.fsf_-_@gnu.org> <168e01eb-ac58-4d39-a960-46624e65edde@elenq.tech> <875xpu3nl7.fsf@gnu.org> <87ldyjm6e0.fsf@gnu.org> <57321eb4-962c-4994-b48a-518943b58941@elenq.tech> Date: Mon, 09 Dec 2024 18:23:32 +0100 Message-ID: <87y10olqi3.fsf@gnu.org> User-Agent: Gnus/5.13 (Gnus v5.13) MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 73188-done Cc: 73188-done@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) Egun on! Finally pushed v4 with slight edits to =E2=80=98NEWS=E2=80=99: 25504ba21 PEG: Add support for `not-in-range` and [^...] ff11753df PEG: Add full support for PEG + some extensions Thank you! Ludo=E2=80=99. From debbugs-submit-bounces@debbugs.gnu.org Sun Dec 22 12:45:12 2024 Received: (at 73188) by debbugs.gnu.org; 22 Dec 2024 17:45:12 +0000 Received: from localhost ([127.0.0.1]:51806 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tPQ0t-0000KR-OY for submit@debbugs.gnu.org; Sun, 22 Dec 2024 12:45:12 -0500 Received: from dane.soverin.net ([185.233.34.38]:54153) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tPQ0r-0000Eo-5I for 73188@debbugs.gnu.org; Sun, 22 Dec 2024 12:45:10 -0500 Received: from smtp.soverin.net (unknown [10.10.4.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by dane.soverin.net (Postfix) with ESMTPS id 4YGT7d172yzmfv; Sun, 22 Dec 2024 17:45:01 +0000 (UTC) Received: from smtp.soverin.net (smtp.soverin.net [10.10.4.99]) by soverin.net (Postfix) with ESMTPSA id 4YGT7c4h2FzL4; Sun, 22 Dec 2024 17:45:00 +0000 (UTC) Authentication-Results: smtp.soverin.net; dkim=pass (2048-bit key; unprotected) header.d=elenq.tech header.i=@elenq.tech header.a=rsa-sha256 header.s=soverin1 header.b=xJ3E2eAS; dkim-atps=neutral DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=elenq.tech; s=soverin1; t=1734889500; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding:autocrypt:autocrypt; bh=bS9V8TwNmtFaE6JSad12MJnWeUYyJHzusRzuApjFKMc=; b=xJ3E2eASNhPUV8PUYG4Eska6/9V1YEYGfB8FX2HxG/gOqt/9TVMy9FIeTLgKwVE4B4I8Y6 4n1792vTvJ1Kz18lkpwXUEaxAJ+IGul/pBAyMwFjLHGj6QGSMUBwl9gAnxWW9mUsqeCa3d xfS7DhRmamP88/gp8VDA8tM7JYM5qNp9I/bFXcewsGSHTPMf0PEkDqBfcAWb3gR+i8rOBl EePAavOcRxV3iuBpzZYCtVl0WqMMHb44flt/dS5zWSH2+rlqjpONViHV9RHDkEDCyIGcJg DMLzjdxMdUmqRCeCH7gBqG3XVm5kO/eUVct3L4+nB8Iiehwr8I8WB2/3S7YFDg== X-CM-Analysis: v=2.4 cv=WMmFXmsR c=1 sm=1 tr=0 ts=6768501c a=boG0PpFrEpR1SC5N/ZD5Tw==:117 a=boG0PpFrEpR1SC5N/ZD5Tw==:17 a=IkcTkHD0fZMA:10 a=MKtGQD3n3ToA:10 a=1oJP67jkp3AA:10 a=uM5J5C1huM0smEr_0h0A:9 a=QEXdDO2ut3YA:10 a=yPy0HX4kI4LsAlP3oO-2:22 X-CM-Envelope: MS4xfKz4/aNfNfdfSRQfidLSCZuLzHDr/qozVo0YApwLNR4X8kmEyD0hOUTkeE/xFExxIWx+pnD5utmwU133bs7xpA5PtIQwl+UguFEpWf4FnqmSU1MfrrjP 0LydrF942TF7SOWkQAWcjNKSAWMCrVsFODai/Ob4cpgtPk2JTnl+olbgr1eXgltYROf30OdUu4D5hZJ3I+IvU1gi+IcnojQUo3o= Message-ID: Date: Sun, 22 Dec 2024 18:45:00 +0100 MIME-Version: 1.0 To: 73188@debbugs.gnu.org Subject: PEG parser does not support full PEG grammar Content-Language: en-US, es-ES, eu From: Ekaitz Zarraga Autocrypt: addr=ekaitz@elenq.tech; keydata= xsFNBGcvh/QBEACePF16wEeQaqfJNgeaSQB6ty6PzLaYtl8UVApPSCF1PYNEhDtxQOOpBXeu k6h68cjhRX7hmug8mAraXotw4aG4Z3kbUro4fzXOYW3rCi/mAm5NFXLUmBX3E1AV1pcD8hDA 5s3LeGzfTo4xRGTW4zTzxGEyrvbChkVib7wTSk52a/WkFas6l3sXnepF8HmIEOWkwQcYdcuo gaNDFP1kjZYvqfKJXmCZnY+lC8Zfe/vlD/x8FZQYBQ5xgXIfbSR0xlRz/XIHfJv6j+3myUUr 2UKMku1dkjlkhNkyfw+RypQzmbJ0oJ4bk76/ju0nnlN65/LvyeTVUh/2O2VnPnZ49keL8sqr APXF4di4pWT+/mPxfoEtiSDtjyzbr8+ajcwLa4SSKLlexqjZj8X6R4tt31Rf/Pliwe4TdPmd 2leE3BIJl9bAuslEvd5tqZ1oa3Zfb62tvpaJCRYMtOEWuGkYdyrwTW7UXJPQpam4X7WoW2jW c5aTpAnpnqIPzaWJmua1lGQjEXgt4xvVdhVmZq32fkTy/rXw9l5a+XU7N4/Zz8AR/0xO+UBc Q1J+wHADjL8Q0v0tZLEaiWL72AsxN3GMWNPXWAplaTPUNPUlNK0JPHwhTX/cQVkIc9avSKc3 BeUofC96d13I7QmRjQ0gcBaLtV9lMOuYwbC+6tb70x2fQsI3bwARAQABzSJFa2FpdHogWmFy cmFnYSA8ZWthaXR6QGVsZW5xLnRlY2g+wsGUBBMBCAA+FiEEXb4j05BTZSZ/jMdq/blSvT9z VtYFAmcvh/QCGwMFCQPCZwAFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQ/blSvT9zVtbW CRAAkbla35s8RKhQBweqwEcdYDV2Zpt16OgENymjLs/qhh7Y9WgWZ0YraSNYDGCt6lemhior vrXX48+yZC98c8ZgCrr4Hmt8i/6TvJqVhwlZ9//3W/z/YuYDtUPBzRHgwM8tejiXmNqYM8lF Jg64pQaczmGAR29Xf0WTQegSociBSUg9eC7BS74Uh7UbHCgytyretoKmqJAp8SKE/Czt5x4R lXKVgGawzg1GerriwnNbudy0eyl1q0Pn7Q+K+tQ14EPDAM+QsGR/fBV4a3uYP6sBF+SdM+DO LX5MRVbWJ8O3kLmbAKQeLgSLlnYydMY/mTvjgxMAakfGCA4q69gmyDSB0fzAUm3c1JV5VwIo 63rykiOEB/k2m4aiiujH5kOC86sjb273+XXWlOhOEO/vKHHdAh+B7dnEEYUPXnUEMQ23PaF4 22u7C62kw3yH/krKr60t5FxcqNWtCOxEWc0WMZw12Q3Gw8+9oA5DI/f4gjlGvQiQWqj6dvoX vIDmifr0R3sTi6xh+udu2Rp8PsKOW8ZRyQ0/VOiwzBfQkf4PFowaiRp8LnkjLEVft6ruuA1h awO2SKKJ8WpgZPw5oMigZR5DgbunxMD4BcqmD7bSoTRV/ljx1I8UgAaQLPqVVnLt31iENtLv 43kPHl56AbYpAzcvf8nGU3KPhGOoByyuyph4RYDOwU0EZy+H9AEQANc9vw7DnBeNGKhq1Bg5 oiGII7npGXCChe7PB6CJjkvN6n1kXrvBYsaORXvZJPNgmBTKu/ETGYS0t0YeGlI4WTOK9dgB /7T8dngRmrGjPmZjryzfk18tXnJq0zoLixLizDT3FqV4jOG5KjPTxQvpdBMiX9oX4Je2OMqF d14fopLGav0rW7Fh5p83OSREpXbJUJJiUaH3p9U9Ss8IBHzr669PViAqe09EfxL/L0l1JIFj HQjJcg01PUXZAW6aPtd7q6eNCSLTXYPiDRQe2GdRUcB7WfqCogR/LEpzLLcd0NkxCnc0T6da rq2Dupt8rvQ95L4/cOGVcDUDOGE6U92XCkaCvUQkypxQCGKSEjbTFoLRG/4JQj0pAWSaqxPS 7hkTFql4qUAdRwzHN1ib6XedcFfqHSy2Mk5ttW8DaBGKhCm7Mn6+4smXENHSuQxCqHlCQ2m+ 9ogpbxavNVfAblE/ucxyfyo6FlDbGHEG3Yu5296kUPT7PqZLiR3KetMPJfCLY2jVPio3t4tD s7Sj41sG5aIwEApb0Zoz3bPBt5O5GUoPFnXyjO306WLxXrM2tjY38jwHxF1Qvs3HQTJgRei2 g3D3KiiR27cXXs/8lrr8tblr5J1tE4TaQCea5lDuEgTCDLnlcopoYcKpFAUBGQtzcNkudT9w sM2nf9y6INcUE3FlABEBAAHCwXwEGAEIACYWIQRdviPTkFNlJn+Mx2r9uVK9P3NW1gUCZy+H 9AIbDAUJA8JnAAAKCRD9uVK9P3NW1td1D/4xx8AbDKAKx9ezT6GdTZbK6FS66qRQCEzTa5MX ZCEogASOla71CB10l5fFtsRWCtNQLzmgwkFwhdxyjqendDgacc5v/71NBb5KpKni6wDJMeiG s3Lq3ZgWfHte3NZ99iSH+La3aBSFbCloJ/Yf/MJBkzrm1sTTKcgF9/i0pzkume5vtpKRDjjS z4abHu7qk4Sgi5gwWpoKFTT38q6nLP+9SUla3JJjNqU3gvn8kwv6KDMKc4marnSp/c+5O6E+ lNrxMdD0n8+io/Bf/UEI6BU8F7JshPq732bHN1NzUXvgMd4cNsAlvsWM8UCKZ4/usFl1euMM FOvnadZinsTHpXhahJzkYWA7nAKbCoNNq9LPtWxfjHsIfhs+QQafF31Pw+jqHqruB4tH0eiL abrz7kejaZvJdVipNIzRUWYnpP+18khep2UtT1n9VNs6QNb4cHPsoe+s4ga4ZK/klCdEhLya XtbcaNEHb7NZUOBj3HhKFgIY8PD1AptAObHjsUNF5+jfEnl+5WjwyTZTIgDRiOrwn8LWOANQ 0JpR69t06uJwmiogQgnlYe36YFaauHGQZFa+L+R2zgnGn8TnR4C3tH7gNAef9+PKqgmJT5pN IkFzlDmZi05E9xzhj4WQ/OOsqU64eHL2PaDk+2TdfrzNwNFbkABJ+C7BHNAytQ6h9cpUbg== Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 7bit X-Spampanel-Class: ham X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 73188 Cc: =?UTF-8?Q?Ludovic_Court=C3=A8s?= X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) hi! I didn't realize but you pushed the v4, and I detected a bug in it so I sent v5. The bug is in the [^...] implementation. v5 fixes it and it even simplifies the code. Please revert 25504ba21 and apply the v5 instead. From debbugs-submit-bounces@debbugs.gnu.org Sun Dec 22 15:01:54 2024 Received: (at 73188) by debbugs.gnu.org; 22 Dec 2024 20:01:54 +0000 Received: from localhost ([127.0.0.1]:52036 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tPS9C-0006rp-39 for submit@debbugs.gnu.org; Sun, 22 Dec 2024 15:01:54 -0500 Received: from dane.soverin.net ([185.233.34.35]:43791) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tPS9A-0006rU-50 for 73188@debbugs.gnu.org; Sun, 22 Dec 2024 15:01:53 -0500 Received: from smtp.soverin.net (unknown [10.10.4.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by dane.soverin.net (Postfix) with ESMTPS id 4YGX9N02STzm0R; Sun, 22 Dec 2024 20:01:44 +0000 (UTC) Received: from smtp.soverin.net (smtp.soverin.net [10.10.4.100]) by soverin.net (Postfix) with ESMTPSA id 4YGX9M3jwwzKP; Sun, 22 Dec 2024 20:01:43 +0000 (UTC) Authentication-Results: smtp.soverin.net; dkim=pass (2048-bit key; unprotected) header.d=elenq.tech header.i=@elenq.tech header.a=rsa-sha256 header.s=soverin1 header.b=uooGzd2n; dkim-atps=neutral DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=elenq.tech; s=soverin1; t=1734897703; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding; bh=WKAT+doDKVCzr0eATcFSjmLx56dOO2qGUzeeGWzDhk8=; b=uooGzd2nwUmAUE5U+Ze/Q+VlOX06virdJ+qs++jKeix0X20ssoVz3kbMIIzWtW0TfRmte+ Zug86/GyWOYm0P5kS3ErogMeh9ll+wLppfEvZw91rq1dshOeic6rM8id4u2eKeBQCDuMgS Y3na6YEvoTETlelcn0fnwbdOae5VhfFaR/Zo7VeN/Aaow+v/M+iFt9+ylFcIhSrnLg4EcU J3ynFzG01FxNar57NxPLGXzaPsj2VUb+u9k9GChHMEmvJjcoDz77kjRmqU0hJeQtjN0cZv NVHPBAt+nLzIno/Hl0TFvjDZAJNOqHbCc9xKESNetKQeAyX7vfA0HSg6uIGyDw== X-CM-Analysis: v=2.4 cv=e8f8Sbp/ c=1 sm=1 tr=0 ts=67687027 a=boG0PpFrEpR1SC5N/ZD5Tw==:117 a=boG0PpFrEpR1SC5N/ZD5Tw==:17 a=MKtGQD3n3ToA:10 a=1oJP67jkp3AA:10 a=AFO7XXENPAvNZfnen8EA:9 a=yPy0HX4kI4LsAlP3oO-2:22 X-CM-Envelope: MS4xfCuz6DNNhYc+vX0hNXu2u90fIeXmbpHwDj3DHa7FsEcfjj11BOsDV54dyB+QtXwhRFnNexT4vi+mx+AnFvnjUmiC/bmgivuZ0bwQe5whZdOWsBQurGh/ lbF458Riykah1IJ+n36B1+E6xiwRydwes1kgLt75yDiCTa6qkcOplUZcutBfd4N7WfLCx1EvAn1sgDIYjN/OuRJYpN6i79mQGxK6M/jdp/HnrdxOOKb8+XGq Ig887D2BR+k78doS9mnqCQ== From: Ekaitz Zarraga To: 73188@debbugs.gnu.org Subject: [PATCH 1/3] PEG: fix [^...] Date: Sun, 22 Dec 2024 21:01:06 +0100 Message-ID: <20241222200128.13782-1-ekaitz@elenq.tech> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Spampanel-Class: ham X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 73188 Cc: ludo@gnu.org, Ekaitz Zarraga X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) --- module/ice-9/peg/string-peg.scm | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/module/ice-9/peg/string-peg.scm b/module/ice-9/peg/string-peg.scm index 0026f8930..745d8e8e7 100644 --- a/module/ice-9/peg/string-peg.scm +++ b/module/ice-9/peg/string-peg.scm @@ -301,11 +301,19 @@ EndOfFile < !. (define (Literal->defn lst for-syntax) (apply string (map (lambda (x) (Char->defn x for-syntax)) (cdr lst)))) -;; (NotInClass ...) -;; `-> (and ...) +;; (NotInClass (Range ...) (Range ...)) +;; `-> (and (followed-by (not-in-range ...)) +;; (followed-by (not-in-range ...)) +;; ... +;; (not-in-range ...)) +;; NOTE: the order doesn't matter, because all `not-in-range`s will always +;; parse exactly one character, but all the elements but the last need not to +;; consume the input. (define (NotInClass->defn lst for-syntax) - #`(and #,@(map (lambda (x) (NotInRange->defn x for-syntax)) - (cdr lst)))) + #`(and + #,@(map (lambda (x) #`(followed-by #,(NotInRange->defn x for-syntax))) + (cddr lst)) + #,(NotInRange->defn (cadr lst) for-syntax))) ;; (Class ...) ;; `-> (or ...) -- 2.46.0 From debbugs-submit-bounces@debbugs.gnu.org Sun Dec 22 15:02:03 2024 Received: (at 73188) by debbugs.gnu.org; 22 Dec 2024 20:02:03 +0000 Received: from localhost ([127.0.0.1]:52043 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tPS9K-0006sN-Dn for submit@debbugs.gnu.org; Sun, 22 Dec 2024 15:02:03 -0500 Received: from dane.soverin.net ([185.233.34.30]:51111) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tPS9I-0006rx-Fe for 73188@debbugs.gnu.org; Sun, 22 Dec 2024 15:02:01 -0500 Received: from smtp.soverin.net (c04smtp-lb01.int.sover.in [10.10.4.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by dane.soverin.net (Postfix) with ESMTPS id 4YGX9Z3xgBz2xQt; Sun, 22 Dec 2024 20:01:54 +0000 (UTC) Received: from smtp.soverin.net (smtp.soverin.net [10.10.4.100]) by soverin.net (Postfix) with ESMTPSA id 4YGX9Y1M3dzKP; Sun, 22 Dec 2024 20:01:53 +0000 (UTC) Authentication-Results: smtp.soverin.net; dkim=pass (2048-bit key; unprotected) header.d=elenq.tech header.i=@elenq.tech header.a=rsa-sha256 header.s=soverin1 header.b=FLeyxawZ; dkim-atps=neutral DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=elenq.tech; s=soverin1; t=1734897714; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=9UAu1ynsN/4mHorNAcnoU6RAMZF+lAEAhTag7V5LLR8=; b=FLeyxawZDgewsApium7luAhT221KjmZhfqHLnE115I9DL5UGi6s0qr/u8YzD6tQOHtSwnr hLBHKadIcTD5/m2AdXGA9lBeWFOVkCR9aMUr4BPY8XvpCLeMIkuaQOaH5+BWL0aNtx8egS H0Fn0KTVWbXslIsZ+LwXzra49pSosDIkaNHcScA/RXugLEVXLk1Zb2R1xEpo00G6pdcZeU bvv7tR0u2cgh888TxCvuZuObOsrg8MdI4vgPd5qPnZ99H1exHsszP1HsL+JjrjuEYuKqwN PhDQLfCj2KR9zq3MneHad6Xj3vvcYTD8WwKQAvDzrEbNBrivas/7HvJmMxp5aA== X-CM-Envelope: MS4xfLzHidv8mPwe1gg24dKsV7TMyeiunZ2BdPub/h/aaX92h2XE3QZCxhMnshETB6jJv2iUAwBobSZKiWt4tElLsamclM8PMgY79ppaV92UNuV7nIjT5mDV 9L+xZRpDqFraGS9XOVwYKTky4gkmDLtfCmcgna8vduuViRudjIssHHp4dqLNLa1srVvFdy05+EZ6LepwSA81tXyhIAFihG9S4YS3AKnIHRd38dxNrPkAXf7H YjWlZI2+dmeXp6Lx50W9yA== X-CM-Analysis: v=2.4 cv=UsCZN/wB c=1 sm=1 tr=0 ts=67687032 a=boG0PpFrEpR1SC5N/ZD5Tw==:117 a=boG0PpFrEpR1SC5N/ZD5Tw==:17 a=MKtGQD3n3ToA:10 a=1oJP67jkp3AA:10 a=NEAV23lmAAAA:8 a=ekYV4lpRAAAA:8 a=I0CVDw5ZAAAA:8 a=aInjHplUd54IY3E55FIA:9 a=UNA1SJA-vpUoCqqO:21 a=4IeJLL4p9JcA:10 a=mrCxpU6zTNQDHnudu_9Q:22 a=yPy0HX4kI4LsAlP3oO-2:22 From: Ekaitz Zarraga To: 73188@debbugs.gnu.org Subject: [PATCH 3/3] PEG: add large string-peg patch Date: Sun, 22 Dec 2024 21:01:08 +0100 Message-ID: <20241222200128.13782-3-ekaitz@elenq.tech> In-Reply-To: <20241222200128.13782-1-ekaitz@elenq.tech> References: <20241222200128.13782-1-ekaitz@elenq.tech> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Spampanel-Class: ham X-Spam-Score: -0.7 (/) X-Debbugs-Envelope-To: 73188 Cc: ludo@gnu.org, Ekaitz Zarraga X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.7 (-) --- test-suite/tests/peg.test | 117 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 113 insertions(+), 4 deletions(-) diff --git a/test-suite/tests/peg.test b/test-suite/tests/peg.test index d9e3e1b22..d8d047288 100644 --- a/test-suite/tests/peg.test +++ b/test-suite/tests/peg.test @@ -86,7 +86,7 @@ End <-- '*)' C <- Begin N* End N <- C / (!Begin !End Z) -Z <- [^X-Z]") ;; Forbid some characters to test not-in-range +Z <- .") =20 ;; A short /etc/passwd file. (define *etc-passwd* @@ -126,9 +126,6 @@ SLASH < '/'") (match-pattern C "(*blah*)") (make-prec 0 8 "(*blah*)" '((Begin "(*") "blah" (End "*)"))))) - (pass-if - "simple comment with forbidden char" - (not (match-pattern C "(*blYh*)"))) (pass-if "simple comment padded" (equal? @@ -288,3 +285,115 @@ number <-- [0-9]+") (equal? (eq-parse "1+1/2*3+(1+1)/2") '(+ (+ 1 (* (/ 1 2) 3)) (/ (+ 1 1) 2))))) =20 + +(define html-grammar +" +# Based on code from https://github.com/Fantom-Factory/afHtmlParser +# 2014-2023 Steve Eynon. This code was originally released under the follo= wing +# terms: +# +# Permission to use, copy, modify, and/or distribute this software fo= r any +# purpose with or without fee is hereby granted, provided that the ab= ove +# copyright notice and this permission notice appear in all copies. +# +# THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL +# WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRA= NTIES +# OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIA= BLE +# FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY +# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHE= THER +# IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARIS= ING +# OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWAR= E. + +# PEG Rules for parsing well formed HTML 5 documents +# https://html.spec.whatwg.org/multipage/syntax.html + +html <-- bom? blurb* doctype? blurb* xmlProlog? blurb* elem blurb* +bom <-- \"\\uFEFF\" +xmlProlog <-- \"\" .)+ \"?>\" + +# ---- Doctype ---- + +doctype <-- \"\" +doctypePublicId <-- [ \\t\\n\\f\\r]+ \"PUBLIC\" [ \\t\\n\\f\\r]+ ((\"= \\\"\" [^\"]* \"\\\"\") / (\"'\" [^']* \"'\")) +doctypeSystemId <-- [ \\t\\n\\f\\r]+ (\"SYSTEM\" [ \\t\\n\\f\\r]+)? ((\"= \\\"\" [^\"]* \"\\\"\") / (\"'\" [^']* \"'\")) + +# ---- Elems ---- + +elem <-- voidElem / rawTextElem / escRawTextElem / selfClosin= gElem / normalElem +voidElem <-- \"<\" voidElemName attributes \">\" +rawTextElem <-- \"<\" rawTextElemName attributes \">\" rawTextC= ontent endElem +escRawTextElem <-- \"<\" escRawTextElemName attributes \">\" escRawTe= xtContent endElem +selfClosingElem <-- \"<\" elemName attributes \"/>\" +normalElem <-- \"<\" elemName attributes \">\" normalCo= ntent? endElem? +endElem <-- \"\" + +elemName <-- [a-zA-Z] [^\\t\\n\\f />]* +voidElemName <-- \"area\" / \"base\" / \"br\" / \"col\" / \"embed\"= / + \"hr\" / \"img\" / \"input\" / \"keygen\" / \"link\"= / + \"meta\" / \"param\" / \"source\" / \"track\" / \"wb= r\" +rawTextElemName <-- \"script\" / \"style\" +escRawTextElemName <-- \"textarea\" / \"title\" + +rawTextContent <-- (!(\"\" / \"\") .)+ +escRawTextContent <-- ((!(\"\" / \"\" / \"&\") .)+ / = charRef)* +normalContent <-- !\"] ([ \\t]+ / doubleQuoteAttr / singleQuoteAttr= / unquotedAttr / emptyAttr))* +attrName <-- [^ \\t\\n\\r\\f\"'>/=3D]+ +emptyAttr <-- attrName+ +unquotedAttr <-- attrName [ \\t]* \"=3D\" [ \\t]* (charRef / [^ = \\t\\n\\r\\f\"'=3D<>`&]+)+ +singleQuoteAttr <-- attrName [ \\t]* \"=3D\" [ \\t]* \"'\" (charRef / [= ^'&]+)* \"'\" +doubleQuoteAttr <-- attrName [ \\t]* \"=3D\" [ \\t]* \"\\\"\" (charRef /= [^\"&]+)* \"\\\"\" + +# ---- Character References ---- + +charRef <-- &\"&\" (decNumCharRef / hexNumCharRef / namedCharRef /= borkedRef) +namedCharRef <-- \"&\" [^;>]+ \";\" +decNumCharRef <-- \"&#\" [0-9]+ \";\" +hexNumCharRef <-- \"&#x\" [a-fA-F0-9]+ \";\" +borkedRef <-- \"&\" &[ \\t] + +# ---- Misc ---- + +cdata <-- \"\" .)+ \"]]>\" +comment <-- \"\" +blurb <-- [ \\t\\n\\f\\r]+ / comment") + +(define html-example " + + + + Example Domain + + + + + + + +
+

Example Domain

+

This domain is for use in illustrative examples in documents. You m= ay + use this domain in literature without prior coordination or asking for + permission.

= More + information...

+
+ + +") + +(with-test-prefix "Parsing with complex grammars" + (eeval `(define-peg-string-patterns ,html-grammar)) + (pass-if + "HTML parsing" + (equal? + (peg:tree (match-pattern html html-example)) + '(html (blurb "\n") (doctype "") (blurb "\n") (elem (= normalElem "<" (elemName "html") attributes ">" (normalContent "\n" (elem (= normalElem "<" (elemName "head") attributes ">" (normalContent "\n " (el= em (escRawTextElem "<" (escRawTextElemName "title") attributes ">" (escRawT= extContent "Example Domain") (endElem ""))) "\n = " (elem (selfClosingElem "<" (elemName "meta") (attributes " " (doubleQuot= eAttr (attrName "charset") "=3D\"utf-8\"") " ") "/>")) "\n " (elem (self= ClosingElem "<" (elemName "meta") (attributes " " (doubleQuoteAttr (attrNam= e "http-equiv") "=3D\"Content-type\"") " " (doubleQuoteAttr (attrName "cont= ent") "=3D\"text/html; charset=3Dutf-8\"") " ") "/>")) "\n " (elem (self= ClosingElem "<" (elemName "meta") (attributes " " (doubleQuoteAttr (attrNam= e "name") "=3D\"viewport\"") " " (doubleQuoteAttr (attrName "content") "=3D= \"width=3Ddevice-width, initial-scale=3D1\"") " ") "/>")) "\n " (elem (r= awTextElem "<" (rawTextElemName "style") (attributes " " (doubleQuoteAttr (= attrName "type") "=3D\"text/css\"")) ">" (rawTextContent "\n body {\n = background-color: #f0f0f2;\n margin: 0;\n padding: 0;\n = }\n ") (endElem ""))) "\n") (endElem ""))) "\n\n" (elem (normalElem "<" (elemName "body") attri= butes ">" (normalContent "\n" (elem (normalElem "<" (elemName "div") attrib= utes ">" (normalContent "\n " (elem (normalElem "<" (elemName "h1") attr= ibutes ">" (normalContent "Example Domain") (endElem ""))) "\n " (elem (normalElem "<" (elemName "p") attributes ">" (normalC= ontent "This domain is for use in illustrative examples in documents. You m= ay\n use this domain in literature without prior coordination or asking = for\n permission.") (endElem ""))) " " (elem (norma= lElem "<" (elemName "p") attributes ">" (normalContent (elem (normalElem "<= " (elemName "a") (attributes " " (doubleQuoteAttr (attrName "href") "=3D\"h= ttps://www.iana.org/domains/example\"")) ">" (normalContent "More\n info= rmation...") (endElem "")))) (endElem ""))) "\n") (endElem ""))) "\n") (endElem ""))) "\n") (endElem ""))) (blur= b "\n"))))) --=20 2.46.0 From debbugs-submit-bounces@debbugs.gnu.org Sun Dec 22 15:02:32 2024 Received: (at 73188) by debbugs.gnu.org; 22 Dec 2024 20:02:32 +0000 Received: from localhost ([127.0.0.1]:52049 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tPS9o-0006tP-Cu for submit@debbugs.gnu.org; Sun, 22 Dec 2024 15:02:32 -0500 Received: from dane.soverin.net ([185.233.34.25]:58835) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tPS9l-0006t9-Q9 for 73188@debbugs.gnu.org; Sun, 22 Dec 2024 15:02:30 -0500 Received: from smtp.soverin.net (unknown [10.10.4.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by dane.soverin.net (Postfix) with ESMTPS id 4YGX9X2H5czyQG; Sun, 22 Dec 2024 20:01:52 +0000 (UTC) Received: from smtp.soverin.net (smtp.soverin.net [10.10.4.100]) by soverin.net (Postfix) with ESMTPSA id 4YGX9V6tCQzKP; Sun, 22 Dec 2024 20:01:50 +0000 (UTC) Authentication-Results: smtp.soverin.net; dkim=pass (2048-bit key; unprotected) header.d=elenq.tech header.i=@elenq.tech header.a=rsa-sha256 header.s=soverin1 header.b=WKXDZ/e4; dkim-atps=neutral DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=elenq.tech; s=soverin1; t=1734897712; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=VAyGYAaI8Uc0NA+LlgOaavymIAd3ZLF0P1DnwYipqDE=; b=WKXDZ/e4x6O6PpVImB5ckDcaiw3Gm6ou/SwelN9TrBuguZ6dp0JRmfnm0k4EzKCJNAOxKO VsBhcL+KSow57HPJCcW7EJzJ5KQ/I1rnw40Z2Hw64mLpWpaOy8YAAvIcA0vgUdJmw9To/u UogmMvln+j8k1Y1YuODAX83O9R6Uc4z9D4SYQtjN0X1t7s2Akg4G+4Y3NeC/dchBvDt/Cd uuQPuBZY1ejSRky4G3tRyvhYeb199B56+W9NM98gBbkrQ169z11wXfdvb5cHk8SMV/ILju uCq/c4c6Jh+4NGj/PZu01lJ8WVb3AkfoFDyEvvRitrEaXTc7/44eEiFIKSnRWw== X-CM-Envelope: MS4xfK1w8C7vpCT6jPCNrhUr/EJS3mHYD6DgRyRBN0ts+7OJVoS905+j3UNlpmAcsnYrbHUliLdW57ruuB0+Mw5wuRJfguYUag3CZBA8Rfd7eg2JedRVvpIy QaaD8ZAStFtOOPvo88TXjIO6yV2JkfDKkcGIyys6zLZy8IHDor/j7CVW68C6Xe39Mf4wPd4LRDW0brRWr/Sd6WHxWJ4BZW7e91rZlyWN+QH9GU1JXck+N/sv RxyGIiztbVHWTDMbWc8t6g== X-CM-Analysis: v=2.4 cv=WMmFXmsR c=1 sm=1 tr=0 ts=67687030 a=boG0PpFrEpR1SC5N/ZD5Tw==:117 a=boG0PpFrEpR1SC5N/ZD5Tw==:17 a=MKtGQD3n3ToA:10 a=1oJP67jkp3AA:10 a=KnLkD2i1WC7CnZU7tFgA:9 a=yPy0HX4kI4LsAlP3oO-2:22 From: Ekaitz Zarraga To: 73188@debbugs.gnu.org Subject: [PATCH 2/3] PEG: string-peg: better support for escaping Date: Sun, 22 Dec 2024 21:01:07 +0100 Message-ID: <20241222200128.13782-2-ekaitz@elenq.tech> In-Reply-To: <20241222200128.13782-1-ekaitz@elenq.tech> References: <20241222200128.13782-1-ekaitz@elenq.tech> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Spampanel-Class: ham X-Spam-Score: -0.7 (/) X-Debbugs-Envelope-To: 73188 Cc: ludo@gnu.org, Ekaitz Zarraga X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.7 (-) --- module/ice-9/peg/string-peg.scm | 26 +++++++++++++++++++++++--- 1 file changed, 23 insertions(+), 3 deletions(-) diff --git a/module/ice-9/peg/string-peg.scm b/module/ice-9/peg/string-peg.scm index 745d8e8e7..9891f2ae5 100644 --- a/module/ice-9/peg/string-peg.scm +++ b/module/ice-9/peg/string-peg.scm @@ -67,9 +67,10 @@ Literal <-- SQUOTE (!SQUOTE Char)* SQUOTE Spacing NotInClass <-- OPENBRACKET NOTIN (!CLOSEBRACKET Range)* CLOSEBRACKET Spacing Class <-- OPENBRACKET !NOTIN (!CLOSEBRACKET Range)* CLOSEBRACKET Spacing Range <-- Char DASH Char / Char -Char <-- '\\\\' [nrt'\"\\[\\]\\\\] +Char <-- '\\\\' [nrtf'\"\\[\\]\\\\] / '\\\\' [0-7][0-7][0-7] / '\\\\' [0-7][0-7]? + / '\\\\' 'u' HEX HEX HEX HEX / !'\\\\' . # NOTE: `<--` and `<` are extensions @@ -79,6 +80,7 @@ DQUOTE < [\"] DASH < '-' OPENBRACKET < '[' CLOSEBRACKET < ']' +HEX <- [0-9a-fA-F] NOTIN < '^' SLASH < '/' Spacing AND <-- '&' Spacing @@ -92,7 +94,7 @@ DOT <-- '.' Spacing Spacing < (Space / Comment)* Comment < '#' (!EndOfLine .)* EndOfLine -Space < ' ' / '\t' / EndOfLine +Space < ' ' / '\\t' / EndOfLine EndOfLine < '\\r\\n' / '\\n' / '\\r' EndOfFile < !. ") @@ -144,12 +146,15 @@ EndOfFile < !. (define-sexp-parser Range all (or (and Char DASH Char) Char)) (define-sexp-parser Char all - (or (and "\\" (or "n" "r" "t" "'" "\"" "[" "]" "\\")) + (or (and "\\" (or "n" "r" "t" "f" "'" "\"" "[" "]" "\\")) (and "\\" (range #\0 #\7) (range #\0 #\7) (range #\0 #\7)) (and "\\" (range #\0 #\7) (? (range #\0 #\7))) + (and "\\" "u" HEX HEX HEX HEX) (and (not-followed-by "\\") peg-any))) (define-sexp-parser LEFTARROW body (and (or "<--" "<-" "<") Spacing)) ; NOTE: <-- and < are extensions +(define-sexp-parser HEX body + (or (range #\0 #\9) (range #\a #\f) (range #\A #\F))) (define-sexp-parser NOTIN none (and "^")) (define-sexp-parser SLASH none @@ -372,12 +377,27 @@ EndOfFile < !. (* (- (char->integer x) (char->integer #\0)) y)) (reverse (string->list charstr 1)) '(1 8 64))))) + ((char=? #\u (string-ref charstr 1)) + (integer->char + (reduce + 0 + (map + (lambda (x y) + (* (cond + ((char-numeric? x) + (- (char->integer x) (char->integer #\0))) + ((char-alphabetic? x) + (+ 10 (- (char->integer x) (char->integer #\a))))) + y)) + (reverse (string->list (string-downcase charstr) 2)) + '(1 16 256 4096))))) (else (case (string-ref charstr 1) ((#\n) #\newline) ((#\r) #\return) ((#\t) #\tab) + ((#\f) #\page) ((#\') #\') + ((#\") #\") ((#\]) #\]) ((#\\) #\\) ((#\[) #\[)))))) -- 2.46.0 From debbugs-submit-bounces@debbugs.gnu.org Sun Dec 22 15:09:13 2024 Received: (at 73188) by debbugs.gnu.org; 22 Dec 2024 20:09:13 +0000 Received: from localhost ([127.0.0.1]:52061 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tPSGH-0007A8-CP for submit@debbugs.gnu.org; Sun, 22 Dec 2024 15:09:13 -0500 Received: from dane.soverin.net ([185.233.34.38]:45471) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tPSGF-00079u-UD for 73188@debbugs.gnu.org; Sun, 22 Dec 2024 15:09:12 -0500 Received: from smtp.soverin.net (unknown [10.10.4.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by dane.soverin.net (Postfix) with ESMTPS id 4YGXKt2dwRzmwG; Sun, 22 Dec 2024 20:09:06 +0000 (UTC) Received: from smtp.soverin.net (smtp.soverin.net [10.10.4.100]) by soverin.net (Postfix) with ESMTPSA id 4YGXKt07vLzKP; Sun, 22 Dec 2024 20:09:05 +0000 (UTC) Authentication-Results: smtp.soverin.net; dkim=pass (2048-bit key; unprotected) header.d=elenq.tech header.i=@elenq.tech header.a=rsa-sha256 header.s=soverin1 header.b=xwXzklwx; dkim-atps=neutral DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=elenq.tech; s=soverin1; t=1734898146; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:autocrypt:autocrypt; bh=4i4sAf7Hd6mfHUcnW9pcCDmCQisOBp7aG/OgCbccYWo=; b=xwXzklwx+x6G2utdnXuUzBQ/PKQxaMEsK7DtwyohQYiu1af3M8bsOMYkTbhoXq3Sva/IWh cK7rAp1epAFG2MpRUT8TqByT7HFXLUf77mUlyswKAP9cW5Emb3I+8ShbSu+4lYsT7T0rKa O0UeFye2QIfc5e6B26u8C4AwsGVmByFpMsKVFWGqgt2mDDukDnffgkPOPsmQnwC0+EgOHM P1gO17mSnCNCK5DLt2gtoJNna2kukBOpsvF9Cgw7MCGWH/hHtC+7xAhCQZm0jjPHw9J3kT o2Z+lcc4+me+VpGSL9gchTGLWgZ/325HF5sRagoezaqbyFqjLBLpT3ircx158A== X-CM-Analysis: v=2.4 cv=UsCZN/wB c=1 sm=1 tr=0 ts=676871e2 a=boG0PpFrEpR1SC5N/ZD5Tw==:117 a=boG0PpFrEpR1SC5N/ZD5Tw==:17 a=IkcTkHD0fZMA:10 a=MKtGQD3n3ToA:10 a=1oJP67jkp3AA:10 a=uQ4rUJXzlxE0PLoi5KMA:9 a=QEXdDO2ut3YA:10 a=QYH75iMubAgA:10 a=yPy0HX4kI4LsAlP3oO-2:22 X-CM-Envelope: MS4xfIZLP7Dc2TghY+VHSgMV94fmY6IvEE4RA2JLUQPu6/S0giSbD/yi5eAw3naX8O2AQ0Bgjob3L8OBn5Gcy0fNUPIaksNg85rcDhJRzf9wP7t2F44EvOfP i6o2N56+YB+ab/dTRjY+hUw9WDLfAjUGqX8Lx8M2qWhS1EGfL7QNBzee8iEXgObK52sdjbz/jzvICcQDGCeAT7hGSw/epH06s2I= Message-ID: Date: Sun, 22 Dec 2024 21:09:05 +0100 MIME-Version: 1.0 Subject: Re: PEG parser does not support full PEG grammar From: Ekaitz Zarraga To: 73188@debbugs.gnu.org References: Content-Language: en-US, es-ES, eu Autocrypt: addr=ekaitz@elenq.tech; keydata= xsFNBGcvh/QBEACePF16wEeQaqfJNgeaSQB6ty6PzLaYtl8UVApPSCF1PYNEhDtxQOOpBXeu k6h68cjhRX7hmug8mAraXotw4aG4Z3kbUro4fzXOYW3rCi/mAm5NFXLUmBX3E1AV1pcD8hDA 5s3LeGzfTo4xRGTW4zTzxGEyrvbChkVib7wTSk52a/WkFas6l3sXnepF8HmIEOWkwQcYdcuo gaNDFP1kjZYvqfKJXmCZnY+lC8Zfe/vlD/x8FZQYBQ5xgXIfbSR0xlRz/XIHfJv6j+3myUUr 2UKMku1dkjlkhNkyfw+RypQzmbJ0oJ4bk76/ju0nnlN65/LvyeTVUh/2O2VnPnZ49keL8sqr APXF4di4pWT+/mPxfoEtiSDtjyzbr8+ajcwLa4SSKLlexqjZj8X6R4tt31Rf/Pliwe4TdPmd 2leE3BIJl9bAuslEvd5tqZ1oa3Zfb62tvpaJCRYMtOEWuGkYdyrwTW7UXJPQpam4X7WoW2jW c5aTpAnpnqIPzaWJmua1lGQjEXgt4xvVdhVmZq32fkTy/rXw9l5a+XU7N4/Zz8AR/0xO+UBc Q1J+wHADjL8Q0v0tZLEaiWL72AsxN3GMWNPXWAplaTPUNPUlNK0JPHwhTX/cQVkIc9avSKc3 BeUofC96d13I7QmRjQ0gcBaLtV9lMOuYwbC+6tb70x2fQsI3bwARAQABzSJFa2FpdHogWmFy cmFnYSA8ZWthaXR6QGVsZW5xLnRlY2g+wsGUBBMBCAA+FiEEXb4j05BTZSZ/jMdq/blSvT9z VtYFAmcvh/QCGwMFCQPCZwAFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQ/blSvT9zVtbW CRAAkbla35s8RKhQBweqwEcdYDV2Zpt16OgENymjLs/qhh7Y9WgWZ0YraSNYDGCt6lemhior vrXX48+yZC98c8ZgCrr4Hmt8i/6TvJqVhwlZ9//3W/z/YuYDtUPBzRHgwM8tejiXmNqYM8lF Jg64pQaczmGAR29Xf0WTQegSociBSUg9eC7BS74Uh7UbHCgytyretoKmqJAp8SKE/Czt5x4R lXKVgGawzg1GerriwnNbudy0eyl1q0Pn7Q+K+tQ14EPDAM+QsGR/fBV4a3uYP6sBF+SdM+DO LX5MRVbWJ8O3kLmbAKQeLgSLlnYydMY/mTvjgxMAakfGCA4q69gmyDSB0fzAUm3c1JV5VwIo 63rykiOEB/k2m4aiiujH5kOC86sjb273+XXWlOhOEO/vKHHdAh+B7dnEEYUPXnUEMQ23PaF4 22u7C62kw3yH/krKr60t5FxcqNWtCOxEWc0WMZw12Q3Gw8+9oA5DI/f4gjlGvQiQWqj6dvoX vIDmifr0R3sTi6xh+udu2Rp8PsKOW8ZRyQ0/VOiwzBfQkf4PFowaiRp8LnkjLEVft6ruuA1h awO2SKKJ8WpgZPw5oMigZR5DgbunxMD4BcqmD7bSoTRV/ljx1I8UgAaQLPqVVnLt31iENtLv 43kPHl56AbYpAzcvf8nGU3KPhGOoByyuyph4RYDOwU0EZy+H9AEQANc9vw7DnBeNGKhq1Bg5 oiGII7npGXCChe7PB6CJjkvN6n1kXrvBYsaORXvZJPNgmBTKu/ETGYS0t0YeGlI4WTOK9dgB /7T8dngRmrGjPmZjryzfk18tXnJq0zoLixLizDT3FqV4jOG5KjPTxQvpdBMiX9oX4Je2OMqF d14fopLGav0rW7Fh5p83OSREpXbJUJJiUaH3p9U9Ss8IBHzr669PViAqe09EfxL/L0l1JIFj HQjJcg01PUXZAW6aPtd7q6eNCSLTXYPiDRQe2GdRUcB7WfqCogR/LEpzLLcd0NkxCnc0T6da rq2Dupt8rvQ95L4/cOGVcDUDOGE6U92XCkaCvUQkypxQCGKSEjbTFoLRG/4JQj0pAWSaqxPS 7hkTFql4qUAdRwzHN1ib6XedcFfqHSy2Mk5ttW8DaBGKhCm7Mn6+4smXENHSuQxCqHlCQ2m+ 9ogpbxavNVfAblE/ucxyfyo6FlDbGHEG3Yu5296kUPT7PqZLiR3KetMPJfCLY2jVPio3t4tD s7Sj41sG5aIwEApb0Zoz3bPBt5O5GUoPFnXyjO306WLxXrM2tjY38jwHxF1Qvs3HQTJgRei2 g3D3KiiR27cXXs/8lrr8tblr5J1tE4TaQCea5lDuEgTCDLnlcopoYcKpFAUBGQtzcNkudT9w sM2nf9y6INcUE3FlABEBAAHCwXwEGAEIACYWIQRdviPTkFNlJn+Mx2r9uVK9P3NW1gUCZy+H 9AIbDAUJA8JnAAAKCRD9uVK9P3NW1td1D/4xx8AbDKAKx9ezT6GdTZbK6FS66qRQCEzTa5MX ZCEogASOla71CB10l5fFtsRWCtNQLzmgwkFwhdxyjqendDgacc5v/71NBb5KpKni6wDJMeiG s3Lq3ZgWfHte3NZ99iSH+La3aBSFbCloJ/Yf/MJBkzrm1sTTKcgF9/i0pzkume5vtpKRDjjS z4abHu7qk4Sgi5gwWpoKFTT38q6nLP+9SUla3JJjNqU3gvn8kwv6KDMKc4marnSp/c+5O6E+ lNrxMdD0n8+io/Bf/UEI6BU8F7JshPq732bHN1NzUXvgMd4cNsAlvsWM8UCKZ4/usFl1euMM FOvnadZinsTHpXhahJzkYWA7nAKbCoNNq9LPtWxfjHsIfhs+QQafF31Pw+jqHqruB4tH0eiL abrz7kejaZvJdVipNIzRUWYnpP+18khep2UtT1n9VNs6QNb4cHPsoe+s4ga4ZK/klCdEhLya XtbcaNEHb7NZUOBj3HhKFgIY8PD1AptAObHjsUNF5+jfEnl+5WjwyTZTIgDRiOrwn8LWOANQ 0JpR69t06uJwmiogQgnlYe36YFaauHGQZFa+L+R2zgnGn8TnR4C3tH7gNAef9+PKqgmJT5pN IkFzlDmZi05E9xzhj4WQ/OOsqU64eHL2PaDk+2TdfrzNwNFbkABJ+C7BHNAytQ6h9cpUbg== In-Reply-To: Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 7bit X-Spampanel-Class: ham X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 73188 Cc: =?UTF-8?Q?Ludovic_Court=C3=A8s?= X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) The three previous messages (SORRY) add the changes that were missing in when v4 was applied instead of v5. From debbugs-submit-bounces@debbugs.gnu.org Sun Dec 22 16:22:22 2024 Received: (at 73188) by debbugs.gnu.org; 22 Dec 2024 21:22:22 +0000 Received: from localhost ([127.0.0.1]:52170 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tPTP3-00028d-KR for submit@debbugs.gnu.org; Sun, 22 Dec 2024 16:22:21 -0500 Received: from eggs.gnu.org ([209.51.188.92]:51062) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tPTP0-00028Q-SX for 73188@debbugs.gnu.org; Sun, 22 Dec 2024 16:22:20 -0500 Received: from fencepost.gnu.org ([2001:470:142:3::e]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1tPTOu-0005o3-Ig; Sun, 22 Dec 2024 16:22:12 -0500 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnu.org; s=fencepost-gnu-org; h=MIME-Version:Date:References:In-Reply-To:Subject:To: From; bh=ueGsBT1UNOJMzsVF77y6oro4l7PmmFBELIKV9Vfbzh0=; b=m9ckln+oOJ9wpdbmDn/7 YX3+h3LcFPcV7YyRnROKQwSEj6+R/fA0u6GrmzfG3Dp1j8Q1KwN1n2CTe6F8W7mNJFBMEKujeODRU EVy8xqk5JxLXO+X3j45s37t3nbpmeuStDbjZn0Ejv1ZGek86y+rSeK7LnDzuS5ign4YEpvN5Xgyh+ wa9p/lN23liowUEdZe9Rj+eelcr56yD0LGjetNiKfC9L3GxjcxqL0cFs2/tnImj/SRkfhsdSLOQnq sruwmt5MulZiTnqLXYNR4ZHkmYXcmrtks1U4bqA8hBQv13RPiKOOeypBd4aIzj2aXhY6K6yxzOBst clu6NJYcDaUyRg==; From: =?utf-8?Q?Ludovic_Court=C3=A8s?= To: Ekaitz Zarraga Subject: Re: bug#73188: PEG parser does not support full PEG grammar In-Reply-To: <20241222200128.13782-1-ekaitz@elenq.tech> (Ekaitz Zarraga's message of "Sun, 22 Dec 2024 21:01:06 +0100") References: <78a81bc5-cd0d-0506-185b-c733c66e96ae@elenq.tech> <20241222200128.13782-1-ekaitz@elenq.tech> Date: Sun, 22 Dec 2024 22:22:09 +0100 Message-ID: <87seqffm66.fsf_-_@gnu.org> User-Agent: Gnus/5.13 (Gnus v5.13) MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 73188 Cc: 73188@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) Hi Ekaitz, Apologies for applying the wrong version of the patch series! I pushed the 3 patches you just sent: 6750f6cc8 * PEG: string-peg: Add HTML5 grammar test. 38ad26497 * PEG: string-peg: Better support for escaping. c86a48a92 * PEG: string-peg: Fix [^...] interpretation. I added commit logs that follow the project=E2=80=99s conventions (same as Guix). In the future, when a patch fixes a bug, please include a test case that reproduces the bug being fixed; possibly add information in the commit log about the commit that introduced the bug/regression. This is useful to get a good understanding of the situation. (I understand in this case the problem was mostly me applying an earlier version.) And bonus points if you provide commit logs. :-) Thank you! Ludo=E2=80=99. From debbugs-submit-bounces@debbugs.gnu.org Mon Dec 23 17:04:47 2024 Received: (at 73188) by debbugs.gnu.org; 23 Dec 2024 22:04:47 +0000 Received: from localhost ([127.0.0.1]:58344 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tPqXe-0006Jb-K6 for submit@debbugs.gnu.org; Mon, 23 Dec 2024 17:04:47 -0500 Received: from mailout.easymail.ca ([64.68.200.34]:49644) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tPqXc-0006JN-A6 for 73188@debbugs.gnu.org; Mon, 23 Dec 2024 17:04:45 -0500 Received: from localhost (localhost [127.0.0.1]) by mailout.easymail.ca (Postfix) with ESMTP id 4613C60EA2; Mon, 23 Dec 2024 22:04:38 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=bokr.com; s=easymail; t=1734991478; bh=c1hTx3gkNjTGYl3+3xudBUSSgTTVInR3NSs1YOvx0rg=; h=From:Date:To:Cc:Subject:Reply-To:References:In-Reply-To:From; b=OWZGbDg5+ndjJGogWo6zsSvRFVxQTQ6ynCoWASkLSR9YLCFo6DHREEY228i8XW+x+ kCkpyBYpwpEooONQX8FA0XHDcU7HQgPlAabknlAhpeUZm1nsR2EX9w1NYLOC6eeCDJ StgRRSaTgES0YqNV8jA6PeLLLx/fyiPSyMMC4oNAGfFmhNaCOzXXVy4hUpcYJZwdZn bpv1WqhuOwNTzpCCBs0TSWOfY1grD3MNA2y/YI+uOAYQZS7Xf6iBbuV4/qmuxaVL18 7UX7c3QLtKqfhKuozacgbeAtoQA/nPhemrjdSAuQD1Frvchv72E42bl4g6lUd+2KxT mWNmPJ36aax4w== X-Virus-Scanned: Debian amavisd-new at emo09-pco.easydns.vpn Received: from mailout.easymail.ca ([127.0.0.1]) by localhost (emo09-pco.easydns.vpn [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id rccbbpFCKfPy; Mon, 23 Dec 2024 22:04:37 +0000 (UTC) Received: from localhost (unknown [50.208.209.153]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange ECDHE (P-256) server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by mailout.easymail.ca (Postfix) with ESMTPSA id 2FF5C60E9D; Mon, 23 Dec 2024 22:04:37 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=bokr.com; s=easymail; t=1734991477; bh=c1hTx3gkNjTGYl3+3xudBUSSgTTVInR3NSs1YOvx0rg=; h=From:Date:To:Cc:Subject:Reply-To:References:In-Reply-To:From; b=RQqXMRLdqSqujj/+VyTuGWo99gx0RtqkCjlj1GEjnNYNxa7EQGUURloJy9CDoPb4a pZPjSYfSzDq4/g916ta9o0E/I0X5tvMVPaE0N2flMJD+9lCSM9BLc/NJMXl67OtERN OV9aLmubI0O9Wb9Xa05nji4Ni43Z1nnmc6gypWmqodvb/J+ytG+fVLSGIhg/oWVc00 M5H6LZ2IYrfEL2p+vj2ENT7dqXoRVl4HuXtg+35XHjo32J9h1m5L6EH/66BrheXmA0 2OID2V0QqdTwfwk2DnWiq5o66g9MENhVpYRU5SF3zbMeu/Bu2gPED1wzVzxk2H5CWw hgdTL0FoT8Tzw== From: bokr@bokr.com Date: Mon, 23 Dec 2024 14:04:22 -0800 To: Ludovic =?utf-8?Q?Court=C3=A8s?= Subject: Re: bug#73188: PEG parser does not support full PEG grammar Message-ID: References: <78a81bc5-cd0d-0506-185b-c733c66e96ae@elenq.tech> <20241222200128.13782-1-ekaitz@elenq.tech> <87seqffm66.fsf_-_@gnu.org> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <87seqffm66.fsf_-_@gnu.org> X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 73188 Cc: 73188@debbugs.gnu.org, Ekaitz Zarraga X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: bokr@bokr.com Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) • Late kudos to Ekaitz for this great PEG contribution, especially RISCV, which will IMO play a key part in the future of human secure control over machines :) • Is there a trustable git repo I could clone to follow future developments of this work? • IWBN to have an example doc for how to define a DSL and its interpreter a la brainf*ck, but compiled suitable for running in qemu bullet-proof container. Scroll to end of this email for what I was surprised worked, though it may have compromised my system, I'm not sure: CAVEAT! :) On +2024-12-22 22:22:09 +0100, Ludovic Courtès wrote: > Hi Ekaitz, > > Apologies for applying the wrong version of the patch series! > > I pushed the 3 patches you just sent: > > 6750f6cc8 * PEG: string-peg: Add HTML5 grammar test. > 38ad26497 * PEG: string-peg: Better support for escaping. > c86a48a92 * PEG: string-peg: Fix [^...] interpretation. > > I added commit logs that follow the project’s conventions (same as > Guix). > > In the future, when a patch fixes a bug, please include a test case that > reproduces the bug being fixed; possibly add information in the commit > log about the commit that introduced the bug/regression. This is useful > to get a good understanding of the situation. (I understand in this > case the problem was mostly me applying an earlier version.) > > And bonus points if you provide commit logs. :-) > > Thank you! > > Ludo’. > > > -=-=================================-=- Here is what worked way back when ludo published (a release announcement email that IMO is a paragon of release announcements) I'm not suggesting running this as I did, since I am not sure about security bugs, then and since, but I did it back when Ludo realeased it. CAVEAT! YOU HAVE BEEN WARNED! (Tips on published vulns appreciated) But runvm (below) seemed to work amazingly under (debian-based) pureos wayland. $ cd ~/wb/gxqemu/ $ file * guix-system-vm-image-1.4.0.x86_64-linux.qcow2: QEMU QCOW2 Image (v3), 32255246336 bytes runvm: Bourne-Again shell script, ASCII text executable $ ls -ltrad * -rwxr-xr-x 1 bokr bokr 211 Feb 7 2024 runvm -rw-r--r-- 1 bokr bokr 8862695424 Oct 14 02:17 guix-system-vm-image-1.4.0.x86_64-linux.qcow2 $ du -h guix-system-vm-image-1.4.0.x86_64-linux.qcow2 8.3G guix-system-vm-image-1.4.0.x86_64-linux.qcow2 $ cat -nA runvm 1 #!/usr/bin/bash$ 2 $ 3 qemu-system-x86_64 \$ 4 -nic user,model=virtio-net-pci \$ 5 -enable-kvm -m 2048 \$ 6 -device virtio-blk,drive=myhd \$ 7 -drive if=none,file=guix-system-vm-image-1.4.0.x86_64-linux.qcow2,id=myhd$ $ $ # I'm not doing the following, since I am not sure about security bugs, but I did it $ # when Ludo realeased it (with a realease announcement email that IMO is a paragon of $ # relase announcements): $ # $ # ./runvm & $ # in a system with Wayland as the display compositor, this runs the image in the foreground AND $ # continues running the term CLI '(bash)' in the background, amazingly compositing both anything $ # running via X-wayland headless Xorg, like maybe firefox-esr, and the qcow image, so you can $ # mouse around and switch between the two. $ $ # NOTICE: Not responsible for consequences of trying this: YOU HAVE BEEN WARNED :) $ $ uname -a Linux BRL14v1 5.10.0-33-amd64 #1 SMP Debian 5.10.226-1 (2024-10-03) x86_64 GNU/Linux $ pwd /home/bokr/wb/gxqemu $ cd ~/wb/guix/guix $ git log|head commit e92b20a41a026b8af7dd2031eb61267b061617b5 Author: Tomas Volf <~@wolfsden.cz> Date: Fri Dec 13 17:27:46 2024 +0100 services: mingetty: Support waiting on shepherd services. For auto-login on systems with elogind, dbus-system needs to be started. This commit adds ability to express that ordering. * gnu/services/base.scm (): Add shepherd-requirement $ -=-=================================-=- I am interested in using Ekaitz's Peg work and predecessor guile work of Andy Wingo and Ludo to produce secure minimal-code guile extensions displaying popups showing e.g. progress graphics based on direct wayland event protocols, to be able to show status of "hung" looping or deadlocked threads, subject ot user privilege authentication. IIRC the display ran at 60hz before starting the cow2 image and dropped to 30hz when showing both display outputs at the same time. If I get time, I'll try to take a video with my phone to show it, but don't hold your breath ;-) It would be interesting to try a minimal wayland for mes too :) Obviously these are wip-thoughts ;-) Thanks for reading :) Happy Holidays -- With kind regards, Bengt Richter From debbugs-submit-bounces@debbugs.gnu.org Mon Dec 23 17:14:40 2024 Received: (at 73188) by debbugs.gnu.org; 23 Dec 2024 22:14:40 +0000 Received: from localhost ([127.0.0.1]:58359 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tPqhD-0006ka-WA for submit@debbugs.gnu.org; Mon, 23 Dec 2024 17:14:40 -0500 Received: from dane.soverin.net ([185.233.34.149]:53315) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tPqhA-0006kJ-7Q for 73188@debbugs.gnu.org; Mon, 23 Dec 2024 17:14:38 -0500 Received: from smtp.soverin.net (c04smtp-lb01.int.sover.in [10.10.4.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by dane.soverin.net (Postfix) with ESMTPS id 4YHC3W3zrDzyXB; Mon, 23 Dec 2024 22:13:59 +0000 (UTC) Received: from smtp.soverin.net (smtp.soverin.net [10.10.4.99]) by soverin.net (Postfix) with ESMTPSA id 4YHC3V0qJjz40; Mon, 23 Dec 2024 22:13:58 +0000 (UTC) Authentication-Results: smtp.soverin.net; dkim=pass (2048-bit key; unprotected) header.d=elenq.tech header.i=@elenq.tech header.a=rsa-sha256 header.s=soverin1 header.b=sVtqcwfr; dkim-atps=neutral DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=elenq.tech; s=soverin1; t=1734992038; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:autocrypt:autocrypt; bh=cm4fPjjKnhAXfXoKCmyF6suqV0mM280wkXU1J4XG0y8=; b=sVtqcwfrdxOHWEjjwq/cWpcZuaRIZyy1VYkngpUKar2g8OWilE9EeeDr5R6wJORxrOlMe/ 8mvDgMkYGIPkzWozoRUbFVtPByeLkkuiWgNnI96/wr/JH3OT0QnAUW7DjA0hAtgYt2r7sx lzZtMzNwymEgnAJIRB66jHnuQIpM29JZ50OshS4ETNpUwlHlOkUz1mh+ONDoOZxZ4fzl3r hvF5redPFKbF0+QzafeQ0aBlvOwZo/m1w5IL/Fd3AKcKhZU+EkG5n1ukuNl0G9yRAmKlUp EJ3fSD/8rPqw/yDOchXCQze+LXkBmOxwaB+TSd1QPa6jjriNXTj3OAZqM6sgzA== X-CM-Analysis: v=2.4 cv=WMmFXmsR c=1 sm=1 tr=0 ts=6769e0a6 a=boG0PpFrEpR1SC5N/ZD5Tw==:117 a=boG0PpFrEpR1SC5N/ZD5Tw==:17 a=IkcTkHD0fZMA:10 a=MKtGQD3n3ToA:10 a=1oJP67jkp3AA:10 a=p0WdMEafAAAA:8 a=B84WOgZkAAAA:8 a=f3HsL8cA4tsQmgzIGMwA:9 a=3ZKOabzyN94A:10 a=QEXdDO2ut3YA:10 a=rfp43BCc0AMJ3lTcakeD:22 a=yPy0HX4kI4LsAlP3oO-2:22 X-CM-Envelope: MS4xfDJVMPvkCvW1gLZQKsrq5gebb154RGABWcg9wTSciW88OmftSd2KfCGpMh9M/HhfnH+ojVYYBtCNhuYw8Mjc782aIJ5xwYI0NbhWeJrdUsAcJZW7eH/n Q8qeUrF2/XixRkiXGVtAAWzFZa8thL4DjSM8Iv5iJgcLwBfzDRDLWz3H8FI+en85XwkxZugsv5VJhmsBIUDXJHAgBYigPas/7lI= Message-ID: <30f0bc78-51b7-4149-9943-d2550f531189@elenq.tech> Date: Mon, 23 Dec 2024 23:13:57 +0100 MIME-Version: 1.0 Subject: Re: bug#73188: PEG parser does not support full PEG grammar To: bokr@bokr.com References: <78a81bc5-cd0d-0506-185b-c733c66e96ae@elenq.tech> <20241222200128.13782-1-ekaitz@elenq.tech> <87seqffm66.fsf_-_@gnu.org> Content-Language: en-US, es-ES, eu From: Ekaitz Zarraga Autocrypt: addr=ekaitz@elenq.tech; keydata= xsFNBGcvh/QBEACePF16wEeQaqfJNgeaSQB6ty6PzLaYtl8UVApPSCF1PYNEhDtxQOOpBXeu k6h68cjhRX7hmug8mAraXotw4aG4Z3kbUro4fzXOYW3rCi/mAm5NFXLUmBX3E1AV1pcD8hDA 5s3LeGzfTo4xRGTW4zTzxGEyrvbChkVib7wTSk52a/WkFas6l3sXnepF8HmIEOWkwQcYdcuo gaNDFP1kjZYvqfKJXmCZnY+lC8Zfe/vlD/x8FZQYBQ5xgXIfbSR0xlRz/XIHfJv6j+3myUUr 2UKMku1dkjlkhNkyfw+RypQzmbJ0oJ4bk76/ju0nnlN65/LvyeTVUh/2O2VnPnZ49keL8sqr APXF4di4pWT+/mPxfoEtiSDtjyzbr8+ajcwLa4SSKLlexqjZj8X6R4tt31Rf/Pliwe4TdPmd 2leE3BIJl9bAuslEvd5tqZ1oa3Zfb62tvpaJCRYMtOEWuGkYdyrwTW7UXJPQpam4X7WoW2jW c5aTpAnpnqIPzaWJmua1lGQjEXgt4xvVdhVmZq32fkTy/rXw9l5a+XU7N4/Zz8AR/0xO+UBc Q1J+wHADjL8Q0v0tZLEaiWL72AsxN3GMWNPXWAplaTPUNPUlNK0JPHwhTX/cQVkIc9avSKc3 BeUofC96d13I7QmRjQ0gcBaLtV9lMOuYwbC+6tb70x2fQsI3bwARAQABzSJFa2FpdHogWmFy cmFnYSA8ZWthaXR6QGVsZW5xLnRlY2g+wsGUBBMBCAA+FiEEXb4j05BTZSZ/jMdq/blSvT9z VtYFAmcvh/QCGwMFCQPCZwAFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQ/blSvT9zVtbW CRAAkbla35s8RKhQBweqwEcdYDV2Zpt16OgENymjLs/qhh7Y9WgWZ0YraSNYDGCt6lemhior vrXX48+yZC98c8ZgCrr4Hmt8i/6TvJqVhwlZ9//3W/z/YuYDtUPBzRHgwM8tejiXmNqYM8lF Jg64pQaczmGAR29Xf0WTQegSociBSUg9eC7BS74Uh7UbHCgytyretoKmqJAp8SKE/Czt5x4R lXKVgGawzg1GerriwnNbudy0eyl1q0Pn7Q+K+tQ14EPDAM+QsGR/fBV4a3uYP6sBF+SdM+DO LX5MRVbWJ8O3kLmbAKQeLgSLlnYydMY/mTvjgxMAakfGCA4q69gmyDSB0fzAUm3c1JV5VwIo 63rykiOEB/k2m4aiiujH5kOC86sjb273+XXWlOhOEO/vKHHdAh+B7dnEEYUPXnUEMQ23PaF4 22u7C62kw3yH/krKr60t5FxcqNWtCOxEWc0WMZw12Q3Gw8+9oA5DI/f4gjlGvQiQWqj6dvoX vIDmifr0R3sTi6xh+udu2Rp8PsKOW8ZRyQ0/VOiwzBfQkf4PFowaiRp8LnkjLEVft6ruuA1h awO2SKKJ8WpgZPw5oMigZR5DgbunxMD4BcqmD7bSoTRV/ljx1I8UgAaQLPqVVnLt31iENtLv 43kPHl56AbYpAzcvf8nGU3KPhGOoByyuyph4RYDOwU0EZy+H9AEQANc9vw7DnBeNGKhq1Bg5 oiGII7npGXCChe7PB6CJjkvN6n1kXrvBYsaORXvZJPNgmBTKu/ETGYS0t0YeGlI4WTOK9dgB /7T8dngRmrGjPmZjryzfk18tXnJq0zoLixLizDT3FqV4jOG5KjPTxQvpdBMiX9oX4Je2OMqF d14fopLGav0rW7Fh5p83OSREpXbJUJJiUaH3p9U9Ss8IBHzr669PViAqe09EfxL/L0l1JIFj HQjJcg01PUXZAW6aPtd7q6eNCSLTXYPiDRQe2GdRUcB7WfqCogR/LEpzLLcd0NkxCnc0T6da rq2Dupt8rvQ95L4/cOGVcDUDOGE6U92XCkaCvUQkypxQCGKSEjbTFoLRG/4JQj0pAWSaqxPS 7hkTFql4qUAdRwzHN1ib6XedcFfqHSy2Mk5ttW8DaBGKhCm7Mn6+4smXENHSuQxCqHlCQ2m+ 9ogpbxavNVfAblE/ucxyfyo6FlDbGHEG3Yu5296kUPT7PqZLiR3KetMPJfCLY2jVPio3t4tD s7Sj41sG5aIwEApb0Zoz3bPBt5O5GUoPFnXyjO306WLxXrM2tjY38jwHxF1Qvs3HQTJgRei2 g3D3KiiR27cXXs/8lrr8tblr5J1tE4TaQCea5lDuEgTCDLnlcopoYcKpFAUBGQtzcNkudT9w sM2nf9y6INcUE3FlABEBAAHCwXwEGAEIACYWIQRdviPTkFNlJn+Mx2r9uVK9P3NW1gUCZy+H 9AIbDAUJA8JnAAAKCRD9uVK9P3NW1td1D/4xx8AbDKAKx9ezT6GdTZbK6FS66qRQCEzTa5MX ZCEogASOla71CB10l5fFtsRWCtNQLzmgwkFwhdxyjqendDgacc5v/71NBb5KpKni6wDJMeiG s3Lq3ZgWfHte3NZ99iSH+La3aBSFbCloJ/Yf/MJBkzrm1sTTKcgF9/i0pzkume5vtpKRDjjS z4abHu7qk4Sgi5gwWpoKFTT38q6nLP+9SUla3JJjNqU3gvn8kwv6KDMKc4marnSp/c+5O6E+ lNrxMdD0n8+io/Bf/UEI6BU8F7JshPq732bHN1NzUXvgMd4cNsAlvsWM8UCKZ4/usFl1euMM FOvnadZinsTHpXhahJzkYWA7nAKbCoNNq9LPtWxfjHsIfhs+QQafF31Pw+jqHqruB4tH0eiL abrz7kejaZvJdVipNIzRUWYnpP+18khep2UtT1n9VNs6QNb4cHPsoe+s4ga4ZK/klCdEhLya XtbcaNEHb7NZUOBj3HhKFgIY8PD1AptAObHjsUNF5+jfEnl+5WjwyTZTIgDRiOrwn8LWOANQ 0JpR69t06uJwmiogQgnlYe36YFaauHGQZFa+L+R2zgnGn8TnR4C3tH7gNAef9+PKqgmJT5pN IkFzlDmZi05E9xzhj4WQ/OOsqU64eHL2PaDk+2TdfrzNwNFbkABJ+C7BHNAytQ6h9cpUbg== In-Reply-To: Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit X-Spampanel-Class: ham X-Spam-Score: -0.7 (/) X-Debbugs-Envelope-To: 73188 Cc: 73188@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.7 (-) Hi, On 2024-12-23 23:04, bokr@bokr.com wrote: > • Late kudos to Ekaitz for this great PEG contribution, especially RISCV, > which will IMO play a key part in the future of human secure control over machines 🙂 I think I didn't understand your message very well, but just as a clarification: the PEG work and RISC-V work are completely independent, one doesn't have anything to do with the other, and the RISC-V work is not merged in Guile yet. The RISC-V work for the Guile JIT (guile already works in riscv without it) is in here: https://gitlab.com/wingo/lightening/-/merge_requests/14 Hope this clarifies things. From debbugs-submit-bounces@debbugs.gnu.org Sat Dec 28 15:30:56 2024 Received: (at 73188) by debbugs.gnu.org; 28 Dec 2024 20:30:56 +0000 Received: from localhost ([127.0.0.1]:52729 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tRdSa-000845-AV for submit@debbugs.gnu.org; Sat, 28 Dec 2024 15:30:56 -0500 Received: from mailout.easymail.ca ([64.68.200.34]:35934) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tRdSW-00083q-V7 for 73188@debbugs.gnu.org; Sat, 28 Dec 2024 15:30:54 -0500 Received: from localhost (localhost [127.0.0.1]) by mailout.easymail.ca (Postfix) with ESMTP id B980A60231; Sat, 28 Dec 2024 20:30:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=bokr.com; s=easymail; t=1735417846; bh=3J50n7noPHSVvVhM5TlsED81m7VpcE6BkaXTBM7eND8=; h=Date:From:To:Cc:Subject:Reply-To:References:In-Reply-To:From; b=Iyj/bEElKYtsAr9gQBE8H05jwRXEsPxTKr3bxN6HFRinS40auXAvB3LHezwTPmmAg OHkL8DsFLjW/uVx0h94AS/o9XdEHkZ40npB0RYQ/HVRgtotPiGUSWDhr/MVFyrrKuS +BVf3VG6UpfQcUJ/qA9BojP2HqOSK4ERAKATB9vAwTVtpGNlLQipWRYi5Gd8DM9ILg pFudahcfs3Ja3BARxm7bsBFCg1y4AZM9OV9vT5WnP/9R4tFk7n1+1LLLW8DZPtzJm1 hbpmRCQPuFKBGn1kg3ebsSn0GsLSDWkYImeB4JAp4pFYzJ1elxVGEqjLUHb4eU4yS5 eUJx1+rGqkNtg== X-Virus-Scanned: Debian amavisd-new at emo07-pco.easydns.vpn Received: from mailout.easymail.ca ([127.0.0.1]) by localhost (emo07-pco.easydns.vpn [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id opu9HjiMUSbA; Sat, 28 Dec 2024 20:30:46 +0000 (UTC) Received: from localhost (unknown [50.208.209.153]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange ECDHE (P-256) server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by mailout.easymail.ca (Postfix) with ESMTPSA id B12405FDF0; Sat, 28 Dec 2024 20:30:45 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=bokr.com; s=easymail; t=1735417846; bh=3J50n7noPHSVvVhM5TlsED81m7VpcE6BkaXTBM7eND8=; h=Date:From:To:Cc:Subject:Reply-To:References:In-Reply-To:From; b=Iyj/bEElKYtsAr9gQBE8H05jwRXEsPxTKr3bxN6HFRinS40auXAvB3LHezwTPmmAg OHkL8DsFLjW/uVx0h94AS/o9XdEHkZ40npB0RYQ/HVRgtotPiGUSWDhr/MVFyrrKuS +BVf3VG6UpfQcUJ/qA9BojP2HqOSK4ERAKATB9vAwTVtpGNlLQipWRYi5Gd8DM9ILg pFudahcfs3Ja3BARxm7bsBFCg1y4AZM9OV9vT5WnP/9R4tFk7n1+1LLLW8DZPtzJm1 hbpmRCQPuFKBGn1kg3ebsSn0GsLSDWkYImeB4JAp4pFYzJ1elxVGEqjLUHb4eU4yS5 eUJx1+rGqkNtg== Date: Sat, 28 Dec 2024 12:30:32 -0800 From: Bengt Richter To: Ekaitz Zarraga Subject: Re: bug#73188: PEG parser does not support full PEG grammar Message-ID: References: <78a81bc5-cd0d-0506-185b-c733c66e96ae@elenq.tech> <20241222200128.13782-1-ekaitz@elenq.tech> <87seqffm66.fsf_-_@gnu.org> <30f0bc78-51b7-4149-9943-d2550f531189@elenq.tech> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <30f0bc78-51b7-4149-9943-d2550f531189@elenq.tech> X-Spam-Score: 0.7 (/) X-Debbugs-Envelope-To: 73188 Cc: 73188@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: bokr@bokr.com Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -0.3 (/) Hi Ekaitz and anyone interested, Sorry for misunderstandings ;-/ I thought you have made changes which make the MIT PEG standard [1] available in full, and I would like to use that full standard PEG syntax for defining something I have in mind. I realize that guile's underlying VM has a bytecode interpretation loop that is dynamically jit-optimized, and that this is orthogonal to whether the host system is RISCV or whatever, as far as using guile and guix as tools is concerned. (BTW UIAM you have contributed a lot to making this bug-free and clean, for which thanks! ) My interest in RISCV however is as a *target* output language for a compiler I'd like to define with PEG for transforming my peculiar DSL source to output RISCV source, then compile it to an image for execution by RISCV hardware or the quivalent qemu virtual hardware. I'd like to make a tool that can transform any source written in my peculiar ascii/utf8 DSL-syntax to a minimal self-contained bootable-in-RISCV-VM-or-HW ELF file. I can use the current PEG machinery for testing, but I'd like to avoid debugging things you have fixed :) Hence my interest in cloning your repo, so I can start using the MIT syntax [1] and be sure bugs I encounter will be *my* bugs and typos and design/coding mistakes ;-) Also, if I write do-what-i-want.scm using the peg accessible with guile3, the executable will not be a minimal ELF :) Thus my interest in the jit code would be to look for code snippets that I might be able to use for AHOT compilation. Probably someone is already working on something like that. (Anything I think of seems to be WIP somewhere on the internet already :) You write about committing your patches, so I was wondering what git repo you are committing into. I assume you have a private one on your laptop or otherwise near at hand, but are you pushing to some place that I could clone, and then use one of Ludo's magic pre-install incantations to access with use-module in a package definition of mine? BTW, re guix/guile development funding -- I am expecting ARM SOCs with RISCV cores to become important in the hacker/maker embedded world. Could guix/guile earn extra funding by having an investment coop llc that designs actual FLOSS HW/SW/FW and contracts to produce cool devices for profit? (Independent of FSF, and other benevolent sources, but allowing non-controlling investment from them). Sorry to hi-jack this thread. Please start a new one if interested in exploring anything here :) [1] -- Regards, Bengt Richter On +2024-12-23 23:13:57 +0100, Ekaitz Zarraga wrote: > Hi, > > > On 2024-12-23 23:04, bokr@bokr.com wrote: > > • Late kudos to Ekaitz for this great PEG contribution, especially RISCV, > > which will IMO play a key part in the future of human secure control over machines 🙂 > > I think I didn't understand your message very well, but just as a > clarification: the PEG work and RISC-V work are completely independent, one > doesn't have anything to do with the other, and the RISC-V work is not > merged in Guile yet. > > The RISC-V work for the Guile JIT (guile already works in riscv without it) > is in here: > https://gitlab.com/wingo/lightening/-/merge_requests/14 > > Hope this clarifies things. From debbugs-submit-bounces@debbugs.gnu.org Sat Dec 28 15:44:14 2024 Received: (at 73188) by debbugs.gnu.org; 28 Dec 2024 20:44:15 +0000 Received: from localhost ([127.0.0.1]:52756 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tRdfS-00007c-AU for submit@debbugs.gnu.org; Sat, 28 Dec 2024 15:44:14 -0500 Received: from dane.soverin.net ([185.233.34.21]:37021) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tRdfP-00007K-0E for 73188@debbugs.gnu.org; Sat, 28 Dec 2024 15:44:12 -0500 Received: from smtp.soverin.net (c04smtp-lb01.int.sover.in [10.10.4.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by dane.soverin.net (Postfix) with ESMTPS id 4YLDqR6NTbz38; Sat, 28 Dec 2024 20:44:03 +0000 (UTC) Received: from smtp.soverin.net (smtp.soverin.net [10.10.4.100]) by soverin.net (Postfix) with ESMTPSA id 4YLDqR1Yd7zFh; Sat, 28 Dec 2024 20:44:03 +0000 (UTC) Authentication-Results: smtp.soverin.net; dkim=pass (2048-bit key; unprotected) header.d=elenq.tech header.i=@elenq.tech header.a=rsa-sha256 header.s=soverin1 header.b=hMpYimjy; dkim-atps=neutral DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=elenq.tech; s=soverin1; t=1735418643; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:autocrypt:autocrypt; bh=1KdA6FZQrpx4L/i4TMHixzCNF57YTVbNJtoJyDqbggw=; b=hMpYimjyo7e1IhV/OUODkYz/pde5y79kkkXIDb8oewlcrreDQzY1N8Eg/zGebOBTAtZF7D JvNVPYd69NFww/sjWtmJ1vaKyLx1ZgpYIOA39azkSCsNIVz4CVZ0Oafj5ewcvhvZCvqJhT nCVECpxEaAxAECHrH7XbhEBkpHWnp2cSbh6RWrM/Uyybffh6JcXcqFjbx/vQPJWmxGIPOl d4nEakRltlyzj+uuuF5YWlPkWPNQvxYaxdCbklcsyh1a0DOf5tKJNrMaicQl+eg2Ac7PI9 JEXtrUcXApCG8NT2+6e6PcH88qy2odWsTcD3pNQoe1ZlA6JQHfVQ+2+UdpLi3g== X-CM-Envelope: MS4xfOsC4LQBYRDeKKQRZ4fOKVOkNDVBX2X9B/VbFTqpH0Gzlh7V0hV1c0MRaLVoUEQ2vNfAE6jGBl/raMZokt7A4YuBj4QwzymH+n1kUMSByp7bH9cp9/Bo m4YLNc/4NpUCP6zqz6xsKV6Ry8sM+t8VZQ+ORk8h5Hd4C3LnyTF2vLc2ec0oLEFJSGB4t6y6xfLRvx+iRespuNEl9z0uROOzT7A= X-CM-Analysis: v=2.4 cv=UsCZN/wB c=1 sm=1 tr=0 ts=67706313 a=boG0PpFrEpR1SC5N/ZD5Tw==:117 a=boG0PpFrEpR1SC5N/ZD5Tw==:17 a=IkcTkHD0fZMA:10 a=MKtGQD3n3ToA:10 a=1oJP67jkp3AA:10 a=sqvopF12AAAA:8 a=p0WdMEafAAAA:8 a=B84WOgZkAAAA:8 a=E7UFItEdnGTWXStRQXsA:9 a=3ZKOabzyN94A:10 a=QEXdDO2ut3YA:10 a=-FEs8UIgK8oA:10 a=ICY-iCztITyJdCZgv5ou:22 a=rfp43BCc0AMJ3lTcakeD:22 a=yPy0HX4kI4LsAlP3oO-2:22 Message-ID: <64fc6632-03b8-444d-ad50-c98b2c80f174@elenq.tech> Date: Sat, 28 Dec 2024 21:44:02 +0100 MIME-Version: 1.0 Subject: Re: bug#73188: PEG parser does not support full PEG grammar To: bokr@bokr.com References: <78a81bc5-cd0d-0506-185b-c733c66e96ae@elenq.tech> <20241222200128.13782-1-ekaitz@elenq.tech> <87seqffm66.fsf_-_@gnu.org> <30f0bc78-51b7-4149-9943-d2550f531189@elenq.tech> Content-Language: en-US, es-ES, eu From: Ekaitz Zarraga Autocrypt: addr=ekaitz@elenq.tech; keydata= xsFNBGcvh/QBEACePF16wEeQaqfJNgeaSQB6ty6PzLaYtl8UVApPSCF1PYNEhDtxQOOpBXeu k6h68cjhRX7hmug8mAraXotw4aG4Z3kbUro4fzXOYW3rCi/mAm5NFXLUmBX3E1AV1pcD8hDA 5s3LeGzfTo4xRGTW4zTzxGEyrvbChkVib7wTSk52a/WkFas6l3sXnepF8HmIEOWkwQcYdcuo gaNDFP1kjZYvqfKJXmCZnY+lC8Zfe/vlD/x8FZQYBQ5xgXIfbSR0xlRz/XIHfJv6j+3myUUr 2UKMku1dkjlkhNkyfw+RypQzmbJ0oJ4bk76/ju0nnlN65/LvyeTVUh/2O2VnPnZ49keL8sqr APXF4di4pWT+/mPxfoEtiSDtjyzbr8+ajcwLa4SSKLlexqjZj8X6R4tt31Rf/Pliwe4TdPmd 2leE3BIJl9bAuslEvd5tqZ1oa3Zfb62tvpaJCRYMtOEWuGkYdyrwTW7UXJPQpam4X7WoW2jW c5aTpAnpnqIPzaWJmua1lGQjEXgt4xvVdhVmZq32fkTy/rXw9l5a+XU7N4/Zz8AR/0xO+UBc Q1J+wHADjL8Q0v0tZLEaiWL72AsxN3GMWNPXWAplaTPUNPUlNK0JPHwhTX/cQVkIc9avSKc3 BeUofC96d13I7QmRjQ0gcBaLtV9lMOuYwbC+6tb70x2fQsI3bwARAQABzSJFa2FpdHogWmFy cmFnYSA8ZWthaXR6QGVsZW5xLnRlY2g+wsGUBBMBCAA+FiEEXb4j05BTZSZ/jMdq/blSvT9z VtYFAmcvh/QCGwMFCQPCZwAFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQ/blSvT9zVtbW CRAAkbla35s8RKhQBweqwEcdYDV2Zpt16OgENymjLs/qhh7Y9WgWZ0YraSNYDGCt6lemhior vrXX48+yZC98c8ZgCrr4Hmt8i/6TvJqVhwlZ9//3W/z/YuYDtUPBzRHgwM8tejiXmNqYM8lF Jg64pQaczmGAR29Xf0WTQegSociBSUg9eC7BS74Uh7UbHCgytyretoKmqJAp8SKE/Czt5x4R lXKVgGawzg1GerriwnNbudy0eyl1q0Pn7Q+K+tQ14EPDAM+QsGR/fBV4a3uYP6sBF+SdM+DO LX5MRVbWJ8O3kLmbAKQeLgSLlnYydMY/mTvjgxMAakfGCA4q69gmyDSB0fzAUm3c1JV5VwIo 63rykiOEB/k2m4aiiujH5kOC86sjb273+XXWlOhOEO/vKHHdAh+B7dnEEYUPXnUEMQ23PaF4 22u7C62kw3yH/krKr60t5FxcqNWtCOxEWc0WMZw12Q3Gw8+9oA5DI/f4gjlGvQiQWqj6dvoX vIDmifr0R3sTi6xh+udu2Rp8PsKOW8ZRyQ0/VOiwzBfQkf4PFowaiRp8LnkjLEVft6ruuA1h awO2SKKJ8WpgZPw5oMigZR5DgbunxMD4BcqmD7bSoTRV/ljx1I8UgAaQLPqVVnLt31iENtLv 43kPHl56AbYpAzcvf8nGU3KPhGOoByyuyph4RYDOwU0EZy+H9AEQANc9vw7DnBeNGKhq1Bg5 oiGII7npGXCChe7PB6CJjkvN6n1kXrvBYsaORXvZJPNgmBTKu/ETGYS0t0YeGlI4WTOK9dgB /7T8dngRmrGjPmZjryzfk18tXnJq0zoLixLizDT3FqV4jOG5KjPTxQvpdBMiX9oX4Je2OMqF d14fopLGav0rW7Fh5p83OSREpXbJUJJiUaH3p9U9Ss8IBHzr669PViAqe09EfxL/L0l1JIFj HQjJcg01PUXZAW6aPtd7q6eNCSLTXYPiDRQe2GdRUcB7WfqCogR/LEpzLLcd0NkxCnc0T6da rq2Dupt8rvQ95L4/cOGVcDUDOGE6U92XCkaCvUQkypxQCGKSEjbTFoLRG/4JQj0pAWSaqxPS 7hkTFql4qUAdRwzHN1ib6XedcFfqHSy2Mk5ttW8DaBGKhCm7Mn6+4smXENHSuQxCqHlCQ2m+ 9ogpbxavNVfAblE/ucxyfyo6FlDbGHEG3Yu5296kUPT7PqZLiR3KetMPJfCLY2jVPio3t4tD s7Sj41sG5aIwEApb0Zoz3bPBt5O5GUoPFnXyjO306WLxXrM2tjY38jwHxF1Qvs3HQTJgRei2 g3D3KiiR27cXXs/8lrr8tblr5J1tE4TaQCea5lDuEgTCDLnlcopoYcKpFAUBGQtzcNkudT9w sM2nf9y6INcUE3FlABEBAAHCwXwEGAEIACYWIQRdviPTkFNlJn+Mx2r9uVK9P3NW1gUCZy+H 9AIbDAUJA8JnAAAKCRD9uVK9P3NW1td1D/4xx8AbDKAKx9ezT6GdTZbK6FS66qRQCEzTa5MX ZCEogASOla71CB10l5fFtsRWCtNQLzmgwkFwhdxyjqendDgacc5v/71NBb5KpKni6wDJMeiG s3Lq3ZgWfHte3NZ99iSH+La3aBSFbCloJ/Yf/MJBkzrm1sTTKcgF9/i0pzkume5vtpKRDjjS z4abHu7qk4Sgi5gwWpoKFTT38q6nLP+9SUla3JJjNqU3gvn8kwv6KDMKc4marnSp/c+5O6E+ lNrxMdD0n8+io/Bf/UEI6BU8F7JshPq732bHN1NzUXvgMd4cNsAlvsWM8UCKZ4/usFl1euMM FOvnadZinsTHpXhahJzkYWA7nAKbCoNNq9LPtWxfjHsIfhs+QQafF31Pw+jqHqruB4tH0eiL abrz7kejaZvJdVipNIzRUWYnpP+18khep2UtT1n9VNs6QNb4cHPsoe+s4ga4ZK/klCdEhLya XtbcaNEHb7NZUOBj3HhKFgIY8PD1AptAObHjsUNF5+jfEnl+5WjwyTZTIgDRiOrwn8LWOANQ 0JpR69t06uJwmiogQgnlYe36YFaauHGQZFa+L+R2zgnGn8TnR4C3tH7gNAef9+PKqgmJT5pN IkFzlDmZi05E9xzhj4WQ/OOsqU64eHL2PaDk+2TdfrzNwNFbkABJ+C7BHNAytQ6h9cpUbg== In-Reply-To: Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit X-Spampanel-Class: ham X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 73188 Cc: 73188@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) I'll continue with the thread privately. On 2024-12-28 9:30 PM, Bengt Richter wrote: > Hi Ekaitz and anyone interested, > > Sorry for misunderstandings ;-/ > > I thought you have made changes which make the MIT PEG standard [1] available in full, > and I would like to use that full standard PEG syntax for defining something I have in mind. > > I realize that guile's underlying VM has a bytecode interpretation loop that is dynamically > jit-optimized, and that this is orthogonal to whether the host system is RISCV or whatever, > as far as using guile and guix as tools is concerned. (BTW UIAM you have contributed a lot to > making this bug-free and clean, for which thanks! ) > > My interest in RISCV however is as a *target* output language for a compiler I'd like to define > with PEG for transforming my peculiar DSL source to output RISCV source, then compile it > to an image for execution by RISCV hardware or the quivalent qemu virtual hardware. > > I'd like to make a tool that can transform any source written in my peculiar ascii/utf8 DSL-syntax > to a minimal self-contained bootable-in-RISCV-VM-or-HW ELF file. > > I can use the current PEG machinery for testing, but I'd like to avoid debugging things you have fixed :) > Hence my interest in cloning your repo, so I can start using the MIT syntax [1] and be sure bugs > I encounter will be *my* bugs and typos and design/coding mistakes ;-) > > Also, if I write do-what-i-want.scm using the peg accessible with guile3, > the executable will not be a minimal ELF :) > > Thus my interest in the jit code would be to look for code snippets that I might be able to use > for AHOT compilation. Probably someone is already working on something like that. > (Anything I think of seems to be WIP somewhere on the internet already :) > > You write about committing your patches, so I was wondering what git repo you are committing into. > I assume you have a private one on your laptop or otherwise near at hand, but are you pushing to > some place that I could clone, and then use one of Ludo's magic pre-install incantations to access > with use-module in a package definition of mine? > > BTW, re guix/guile development funding -- > I am expecting ARM SOCs with RISCV cores to become important in the hacker/maker embedded world. > > Could guix/guile earn extra funding by having an investment coop llc that designs actual FLOSS HW/SW/FW > and contracts to produce cool devices for profit? (Independent of FSF, and other benevolent sources, > but allowing non-controlling investment from them). > > Sorry to hi-jack this thread. Please start a new one if interested in exploring anything here :) > > [1] > -- > Regards, > Bengt Richter > > On +2024-12-23 23:13:57 +0100, Ekaitz Zarraga wrote: >> Hi, >> >> >> On 2024-12-23 23:04, bokr@bokr.com wrote: >>> • Late kudos to Ekaitz for this great PEG contribution, especially RISCV, >>> which will IMO play a key part in the future of human secure control over machines 🙂 >> >> I think I didn't understand your message very well, but just as a >> clarification: the PEG work and RISC-V work are completely independent, one >> doesn't have anything to do with the other, and the RISC-V work is not >> merged in Guile yet. >> >> The RISC-V work for the Guile JIT (guile already works in riscv without it) >> is in here: >> https://gitlab.com/wingo/lightening/-/merge_requests/14 >> >> Hope this clarifies things. From unknown Thu Jun 19 14:20:19 2025 Received: (at fakecontrol) by fakecontrolmessage; To: internal_control@debbugs.gnu.org From: Debbugs Internal Request Subject: Internal Control Message-Id: bug archived. Date: Sun, 26 Jan 2025 12:24:10 +0000 User-Agent: Fakemail v42.6.9 # This is a fake control message. # # The action: # bug archived. thanks # This fakemail brought to you by your local debbugs # administrator