From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.1.3 (2006-06-01) on yquem.inria.fr X-Spam-Level: * X-Spam-Status: No, score=1.1 required=5.0 tests=AWL,SPF_NEUTRAL autolearn=disabled version=3.1.3 Received: from mail1-relais-roc.national.inria.fr (mail1-relais-roc.national.inria.fr [192.134.164.82]) by yquem.inria.fr (Postfix) with ESMTP id D1343BC69 for ; Mon, 17 Dec 2007 11:55:08 +0100 (CET) X-IronPort-Anti-Spam-Filtered: true X-IronPort-Anti-Spam-Result: AgAAAFfkZUfAXQInh2dsb2JhbACQBQEBAQgKKYEUl0c X-IronPort-AV: E=Sophos;i="4.24,176,1196636400"; d="ml'?scan'208";a="5727359" Received: from concorde.inria.fr ([192.93.2.39]) by mail1-smtp-roc.national.inria.fr with ESMTP; 17 Dec 2007 11:55:09 +0100 Received: from mail4-relais-sop.national.inria.fr (mail4-relais-sop.national.inria.fr [192.134.164.105]) by concorde.inria.fr (8.13.6/8.13.6) with ESMTP id lBHAt7Rk030496 (version=TLSv1/SSLv3 cipher=RC4-SHA bits=128 verify=OK) for ; Mon, 17 Dec 2007 11:55:08 +0100 X-IronPort-AV: E=Sophos;i="4.24,176,1196636400"; d="ml'?scan'208";a="20398491" Received: from peray.inria.fr (HELO ausone.inria.fr) ([128.93.8.98]) by mail4-relais-sop.national.inria.fr with SMTP; 17 Dec 2007 11:55:11 +0100 Received: by ausone.inria.fr (sSMTP sendmail emulation); Mon, _d Dec 2007 11:54:14 +0100 From: "Nicolas Pouillard" Cc: caml-list Subject: Re: [Caml-list] How to Create Sensible Debugging Information when Dynamically Typechecking Code Generated with camlp5 Quotations To: echinuz echinuz References: <266122.53415.qm@web60121.mail.yahoo.com> In-Reply-To: <266122.53415.qm@web60121.mail.yahoo.com> Date: Mon, 17 Dec 2007 11:54:14 +0100 Message-Id: <1197886958-sup-5818@ausone.inria.fr> User-Agent: Sup/0.3 Content-Type: multipart/mixed; boundary="=-1197888854-252014-12227-6963-1-=" MIME-Version: 1.0 X-Miltered: at concorde with ID 4766558C.000 by Joe's j-chkmail (http://j-chkmail . ensmp . fr)! X-Spam: no; 0.00; camlp:01 parser:01 checker:01 camlp:01 mkdir:01 cmo:01 cmo:01 inference:01 runtime:01 foo:01 compilation:01 byte:01 foo:01 runtime:01 byte:01 X-Attachments: cset="UTF-8" type="application/octet-stream" name="alg1.ml" name="alg1.ml" type="application/octet-stream" name="_tags" name="_tags" type="application/octet-stream" name="alg1_test.ml" name="alg1_test.ml" type="application/octet-stream" name="alg1_ant.ml" name="alg1_ant.ml" type="application/octet-stream" name="alg1_ant_test.ml" name="alg1_ant_test.ml" type="application/octet-stream" name="alg1_ant_str.ml" name="alg1_ant_str.ml" type="application/octet-stream" name="alg1_ant_test_bad.ml" name="alg1_ant_test_bad.ml" --=-1197888854-252014-12227-6963-1-= Content-Type: text/plain; charset=UTF-8 Content-Disposition: inline Excerpts from echinuz echinuz's message of Sat Dec 15 20:32:55 +0100 2007: > Allow me to clarify what I meant by type errors and antiquotations. Here is a > very simple program that contains the parser, type checker, and quotation > generator: Ok, I understand your problem and will try to help you using Camlp4 examples based on your original code. In first I attach alg1.ml that is some minimum translation of your code in order to use Camlp4 and to have locations. I also attach a _tags file that helps ocamlbuild to build them. Let's try this first example using alg1_test.ml. $ mkdir algtest $ cd algtest $ cp . $ ocamlbuild alg1.cmo $ cat alg1_test.ml open Alg1;; let x = <:exp< add(21, 21) >>;; let y = <:exp< add(31, 11.0) >>;; $ camlp4of ./_build/alg1.cmo alg1_test.ml open Alg1 let x = App ("add", [ Int 21; Int 21 ]) let y = App ("add", [ Int 31; Flo 11.0 ]) Then let's add antiquotations (alg1_ant.ml), basically one adds a Ant case to the alg type that will hold the antiquoted expression/pattern plus it's type. We embed the type to simplify the dynamic typing and don't involving some type inference. One also embed the type of an expression at runtime in order to check it against the type of the hole. In order to show some useful examples of typing errors one add strings values to the language (alg1_ant_str.ml). Here is the kind of program that we want accept: $ cat alg1_ant_test.ml open Alg1_ant;; let x = <:exp< add(21, 21) >> in let y = <:exp< add(31, 11.0) >> in <:exp< add(add($Int: x$, $Real: y$), 42) >> And the kind of programs that we want to dynamically reject: $ cat alg1_ant_test_bad.ml open Alg1_ant_str;; let x = <:exp< "FOO" >> in <:exp< add(42, $Int:x$) >> Let's try the two new extensions: # Compilation $ ocamlbuild alg1_ant.cmo alg1_ant_str.cmo # Let's look at the result $ camlp4of ./_build/alg1_ant.cmo alg1_ant_test.ml open Alg1_ant let x = ((App ("add", [ Int 21; Int 21 ])), `Int) in let y = ((App ("add", [ Int 31; Flo 11.0 ])), `Real) in ((App ("add", [ App ("add", [ type_check (Loc.of_tuple ("alg1_ant_test.ml", 4, 84, 100, 4, 84, 107, false)) x `Int; type_check (Loc.of_tuple ("alg1_ant_test.ml", 4, 84, 110, 4, 84, 118, false)) y `Real ]); Int 42 ])), `Real) # Let's compile and run the example $ ocamlbuild alg1_ant_test.byte -- # Let's try the bad example to see that there is no static error. $ camlp4of ./_build/alg1_ant_str.cmo alg1_ant_test_bad.ml open Alg1_ant_str let x = ((Str "FOO"), `Str) in ((App ("add", [ Int 42; type_check (Loc.of_tuple ("alg1_ant_test_bad.ml", 3, 47, 63, 3, 47, 69, false)) x `Int ])), `Int) # Finally let's run it to show the runtime check failure. $ ocamlbuild alg1_ant_test_bad.byte -- Dynamic Typing Error at File "alg1_ant_test_bad.ml", line 3, characters 16-22 Fatal error: exception Alg1_ant_str.TypeError Hope that helps Best regards, > --------------------------------------- > #load "pa_extend.cmo";; > #load "q_MLast.cmo";; > > (* Parser *) > type palg= > | PApp of string*palg list > | PInt of string > | PFlo of string;; > > > let g=Grammar.gcreate (Plexer.gmake ());; > let exp_eoi = Grammar.Entry.create g "exp_eoi";; > > EXTEND > GLOBAL: exp_eoi; > exp_eoi: > [[ x = exp; EOI -> x ]] ; > exp: > [[x=INT -> PInt x > | x=FLOAT -> PFlo x > | f = LIDENT; "("; xs=LIST1 SELF SEP ","; ")"-> PApp (f,xs)]]; > END;; > > let parse s = Grammar.Entry.parse exp_eoi (Stream.of_string s);; > > (* Type Checker *) > exception TypeError;; > type integer=[`Int];; > type real=[integer | `Real];; > let rec type_expr=function > | PApp (f,args) -> > (match f with > | "add" -> > if List.length args != 2 then > raise TypeError > else > let args=List.map type_expr args in > (match (List.nth args 0,List.nth args 1) with > | #integer,#integer -> `Int > | #real,#real -> `Real) > | _ -> raise TypeError) > | PInt _ -> `Int > | PFlo _ -> `Real > ;; > > > (* Quotations *) > type alg= > | App of string*alg list > | Int of int > | Flo of float;; > > let loc=Ploc.dummy;; > let rec to_expr=function > | PInt x-> <:expr< Int $int:x$ >> > | PFlo x-> <:expr< Flo $flo:x$ >> > | PApp (f,el)-> > let rec make_el=function > | x::xs -> <:expr< [$x$::$make_el xs$] >> > | [] -> <:expr< [] >> > in > let el=List.map to_expr el in > let el=make_el el in > <:expr< App ($str:f$,$el$) >> > ;; > let rec to_patt=function > | PInt x-> <:patt< Int $int:x$ >> > | PFlo x-> <:patt< Flo $flo:x$ >> > | PApp (f,el)-> > let rec make_el=function > | x::xs -> <:patt< [$x$::$make_el xs$] >> > | [] -> <:patt< [] >> > in > let el=List.map to_patt el in > let el=make_el el in > <:patt< App ($str:f$,$el$) >> > ;; > > let expand_expr s= > let p=parse s in > let t=type_expr p in > to_expr p > ;; > let expand_patt s= > let p=parse s in > let t=type_expr p in > to_patt p > ;; > Quotation.add "exp" (Quotation.ExAst (expand_expr,expand_patt));; > --------------------------------------- > > Thus, by type check, I mean actually verifying the typing rules of the DSL. In > this case, it means that the only function allowed is "add" and that this > function requires two arguments. Now, imagine the above language where > antiquotations are allowed. The parsed AST would have datatype > > type palg= > | PApp of string*palg list > | PInt of string > | PFlo of string > | PQuote of Ploc.t*string > > and it becomes impossible to type check in the above sense since we can not > ascertain the type of PQuote. Now, we can still type check the resulting AST > of type alg (not palg). But, this must occur at runtime rather than during the > preprocessing step at compile time. Therein lies the problem. > > If we discover a type error during runtime, it would be nice to give the user > some indication of where the error occurs short of saying, "Add expects two > arguments." Since the location information provided is relative to the quote, > it can still be challenging to determine exactly where the type error occurs. > Thus, I'm either trying to obtain better location information or perhaps learn > that there's a better place or method to type check than what I'm using. > -- Nicolas Pouillard aka Ertai --=-1197888854-252014-12227-6963-1-= Content-Disposition: attachment; filename="alg1.ml" Content-Type: application/octet-stream; name="alg1.ml" Content-Transfer-Encoding: base64 KCogUGFyc2VyICopCm9wZW4gQ2FtbHA0LlByZUNhc3Q7OwoKdHlwZSBwYWxn PQp8IFBBcHAgb2YgTG9jLnQgKiBzdHJpbmcgKiBwYWxnIGxpc3QgKCogaWYg eW91IHdhbnQgbG9jYXRpb25zLCB5b3UgaGF2ZSB0byBrZWVwIHRoZW0gKikK fCBQSW50IG9mIExvYy50ICogc3RyaW5nCnwgUEZsbyBvZiBMb2MudCAqIHN0 cmluZzs7Cgptb2R1bGUgRyA9IE1ha2VHcmFtKExleGVyKTs7ICgqIGluc3Rl YWQgb2YgbGV0IGc9R3JhbW1hci5nY3JlYXRlIChQbGV4ZXIuZ21ha2UgKCkp OzsgKikKbGV0IGV4cF9lb2kgPSBHLkVudHJ5Lm1rICJleHBfZW9pIjs7ICgq IGluc3RlYWQgb2YgR3JhbW1hci5FbnRyeS5jcmVhdGUgZyAiZXhwX2VvaSI7 OyAqKQoKRVhURU5EIEcgKCogc3BlY2lmeSB3aGljaCBncmFtbWFyIHlvdSBl eHRlbmQgKikKICBHTE9CQUw6IGV4cF9lb2k7CiAgZXhwX2VvaToKICAgIFtb IHggPSBleHA7IGBFT0kgKCogYEVPSSBpbnN0ZWFkIG9mIEVPSSAqKSAtPiB4 IF1dOwogIGV4cDoKICAgIFtbIHggPSBJTlQgLT4gUEludChfbG9jLCB4KQog ICAgIHwgeCA9IEZMT0FUIC0+IFBGbG8oX2xvYywgeCkKICAgICB8IGYgPSBM SURFTlQ7ICIoIjsgeHMgPSBMSVNUMSBTRUxGIFNFUCAiLCI7ICIpIiAtPiBQ QXBwKF9sb2MsIGYsIHhzKSBdXTsKRU5EOzsKCmxldCBwYXJzZSA9IEcucGFy c2Vfc3RyaW5nIGV4cF9lb2k7OyAoKiBpbnN0ZWFkIG9mIGxldCBwYXJzZSBz ID0gR3JhbW1hci5FbnRyeS5wYXJzZSBleHBfZW9pIChTdHJlYW0ub2Zfc3Ry aW5nIHMpOzsgKikKCigqIFR5cGUgQ2hlY2tlciAqKQpleGNlcHRpb24gVHlw ZUVycm9yOzsKdHlwZSBpbnRlZ2VyPVtgSW50XTs7CnR5cGUgcmVhbD1baW50 ZWdlciB8IGBSZWFsXTs7CmxldCByZWMgdHlwZV9leHByPWZ1bmN0aW9uCiAg fCBQQXBwKF9sb2MsIGYsYXJncykgLT4KICAgICAgYmVnaW4gbWF0Y2ggZiwg YXJncyB3aXRoICgqIHBhdHRlcm4gbWF0Y2hpbmcgaXMgeW91ciBmcmllbmQg KikKICAgICAgfCAiYWRkIiwgW2FyZzE7IGFyZzJdIC0+CiAgICAgICAgICAo bWF0Y2ggdHlwZV9leHByIGFyZzEsIHR5cGVfZXhwciBhcmcyIHdpdGgKICAg ICAgICAgICB8ICNpbnRlZ2VyLCNpbnRlZ2VyIC0+IGBJbnQKICAgICAgICAg ICB8ICNyZWFsLCNyZWFsIC0+IGBSZWFsKQogICAgICB8IF8gLT4gTG9jLnJh aXNlIF9sb2MgVHlwZUVycm9yICgqIG5vdGUgdGhlIGxvY2F0aW9uIHdyYXBw aW5nIHRvIGhhdmUgYSBjb3JyZWN0IGxvY2F0aW9uICopCiAgICAgIGVuZAog IHwgUEludCBfIC0+IGBJbnQKICB8IFBGbG8gXyAtPiBgUmVhbAo7OwoKCigq IFF1b3RhdGlvbnMgKikKdHlwZSBhbGc9CnwgQXBwIG9mIHN0cmluZyphbGcg bGlzdAp8IEludCBvZiBpbnQKfCBGbG8gb2YgZmxvYXQ7OwoKKCogT25lIGNh bm5vdCBleHBlY3QgZ29vZCBsb2NhdGlvbnMgd2l0aCB0aGlzIGRlY2xhcmF0 aW9uOiBsZXQgbG9jPVBsb2MuZHVtbXk7OyAqKQpsZXQgcmVjIHRvX2V4cHI9 ZnVuY3Rpb24KICAgIHwgUEludChfbG9jLCB4KSAtPiA8OmV4cHI8IEludCAk aW50OngkID4+CiAgICB8IFBGbG8oX2xvYywgeCkgLT4gPDpleHByPCBGbG8g JGZsbzp4JCA+PgogICAgfCBQQXBwKF9sb2MsIGYsIGVsKS0+CiAgICAgICAg bGV0IHJlYyBtYWtlX2VsPWZ1bmN0aW9uCiAgICAgICAgICAgIHwgeDo6eHMg LT4gPDpleHByPCAkeCQ6OiRtYWtlX2VsIHhzJCA+PgogICAgICAgICAgICAg ICgqIGluc3RlYWQgb2YgPDpleHByPCBbJHgkOjokbWFrZV9lbCB4cyRdID4+ IHNpbmNlIEkndmUgdXNlZCBjYW1scDRvZiAqKQogICAgICAgICAgICB8IFtd IC0+IDw6ZXhwcjwgW10gPj4KICAgICAgICBpbgogICAgICAgIGxldCBlbD1M aXN0Lm1hcCB0b19leHByIGVsIGluCiAgICAgICAgbGV0IGVsPW1ha2VfZWwg ZWwgaW4KICAgICAgICA8OmV4cHI8IEFwcCAoJHN0cjpmJCwkZWwkKSA+Pgo7 OwpsZXQgcmVjIHRvX3BhdHQ9ZnVuY3Rpb24KICAgIHwgUEludChfbG9jLCB4 KSAtPiA8OnBhdHQ8IEludCAkaW50OngkID4+CiAgICB8IFBGbG8oX2xvYywg eCkgLT4gPDpwYXR0PCBGbG8gJGZsbzp4JCA+PgogICAgfCBQQXBwKF9sb2Ms IGYsIGVsKSAtPgogICAgICAgIGxldCByZWMgbWFrZV9lbD1mdW5jdGlvbgog ICAgICAgICAgICB8IHg6OnhzIC0+IDw6cGF0dDwgJHgkOjokbWFrZV9lbCB4 cyQgPj4KICAgICAgICAgICAgfCBbXSAtPiA8OnBhdHQ8IFtdID4+CiAgICAg ICAgaW4KICAgICAgICBsZXQgZWw9TGlzdC5tYXAgdG9fcGF0dCBlbCBpbgog ICAgICAgIGxldCBlbD1tYWtlX2VsIGVsIGluCiAgICAgICAgPDpwYXR0PCBB cHAgKCRzdHI6ZiQsJGVsJCkgPj4KOzsKCmxldCBleHBhbmRfZXhwciBsb2Mg X2xvY19uYW1lIHMgPQogICAgbGV0IHAgPSBwYXJzZSBsb2MgcyBpbgogICAg bGV0IF90ID0gdHlwZV9leHByIHAgaW4KICAgIHRvX2V4cHIgcAo7OwpsZXQg ZXhwYW5kX3BhdHQgbG9jIF9sb2NfbmFtZSBzID0KICAgIGxldCBwID0gcGFy c2UgbG9jIHMgaW4KICAgIGxldCBfdCA9IHR5cGVfZXhwciBwIGluCiAgICB0 b19wYXR0IHAKOzsKCmxldCBleHBhbmRfc3RyX2l0ZW0gbG9jIGxvY19uYW1l IHMgPQogIDw6c3RyX2l0ZW1AbG9jPCAkZXhwOmV4cGFuZF9leHByIGxvYyBs b2NfbmFtZSBzJCA+PgoKbW9kdWxlIFEgPSBTeW50YXguUXVvdGF0aW9uOzsK US5hZGQgImV4cCIgUS5EeW5Bc3QuZXhwcl90YWcgZXhwYW5kX2V4cHI7OwpR LmFkZCAiZXhwIiBRLkR5bkFzdC5wYXR0X3RhZyBleHBhbmRfcGF0dDs7ClEu YWRkICJleHAiIFEuRHluQXN0LnN0cl9pdGVtX3RhZyBleHBhbmRfc3RyX2l0 ZW07Owo= --=-1197888854-252014-12227-6963-1-= Content-Disposition: attachment; filename="_tags" Content-Type: application/octet-stream; name="_tags" Content-Transfer-Encoding: base64 dHJ1ZTogdXNlX2NhbWxwNF9mdWxsLCBjYW1scDRvZgo8YWxnMV90ZXN0Lm1s PjogcHAoY2FtbHA0b2YgLi9hbGcxLmNtbykKPGFsZzFfYW50X3Rlc3QubWw+ OiBwcChjYW1scDRvZiAuL2FsZzFfYW50LmNtbykKPGFsZzFfYW50X3Rlc3Rf YmFkLm1sPjogcHAoY2FtbHA0b2YgLi9hbGcxX2FudF9zdHIuY21vKQo8Ki5i eXRlPjogdXNlX2R5bmxpbmsK --=-1197888854-252014-12227-6963-1-= Content-Disposition: attachment; filename="alg1_test.ml" Content-Type: application/octet-stream; name="alg1_test.ml" Content-Transfer-Encoding: base64 b3BlbiBBbGcxOzsKbGV0IHggPSA8OmV4cDwgYWRkKDIxLCAyMSkgPj47Owps ZXQgeSA9IDw6ZXhwPCBhZGQoMzEsIDExLjApID4+OzsK --=-1197888854-252014-12227-6963-1-= Content-Disposition: attachment; filename="alg1_ant.ml" Content-Type: application/octet-stream; name="alg1_ant.ml" Content-Transfer-Encoding: base64 KCogUGFyc2VyICopCm9wZW4gQ2FtbHA0LlByZUNhc3Q7Owptb2R1bGUgTG9j ID0gQ2FtbHA0LlByZUNhc3QuTG9jOzsKCnR5cGUgcGFsZz0KfCBQQXBwIG9m IExvYy50ICogc3RyaW5nICogcGFsZyBsaXN0ICgqIGlmIHlvdSB3YW50IGxv Y2F0aW9ucywgeW91IGhhdmUgdG8ga2VlcCB0aGVtICopCnwgUEludCBvZiBM b2MudCAqIHN0cmluZwp8IFBGbG8gb2YgTG9jLnQgKiBzdHJpbmcKfCBQQW50 IG9mIExvYy50ICogc3RyaW5nICgqIHRoZSB0eXBlICopICogc3RyaW5nICgq IHRoZSBleHByL3BhdHQgKikKOzsKCm1vZHVsZSBHID0gTWFrZUdyYW0oTGV4 ZXIpOzsgKCogaW5zdGVhZCBvZiBsZXQgZz1HcmFtbWFyLmdjcmVhdGUgKFBs ZXhlci5nbWFrZSAoKSk7OyAqKQpsZXQgZXhwX2VvaSA9IEcuRW50cnkubWsg ImV4cF9lb2kiOzsgKCogaW5zdGVhZCBvZiBHcmFtbWFyLkVudHJ5LmNyZWF0 ZSBnICJleHBfZW9pIjs7ICopCgpFWFRFTkQgRyAoKiBzcGVjaWZ5IHdoaWNo IGdyYW1tYXIgeW91IGV4dGVuZCAqKQogIEdMT0JBTDogZXhwX2VvaTsKICBl eHBfZW9pOgogICAgW1sgeCA9IGV4cDsgYEVPSSAoKiBgRU9JIGluc3RlYWQg b2YgRU9JICopIC0+IHggXV07CiAgZXhwOgogICAgW1sgeCA9IElOVCAtPiBQ SW50KF9sb2MsIHgpCiAgICAgfCB4ID0gRkxPQVQgLT4gUEZsbyhfbG9jLCB4 KQogICAgIHwgZiA9IExJREVOVDsgIigiOyB4cyA9IExJU1QxIFNFTEYgU0VQ ICIsIjsgIikiIC0+IFBBcHAoX2xvYywgZiwgeHMpCiAgICAgfCBgQU5USVFV T1QodHksIHN0cikgLT4gUEFudChfbG9jLCB0eSwgc3RyKSBdXTsKRU5EOzsK CmxldCBwYXJzZSA9IEcucGFyc2Vfc3RyaW5nIGV4cF9lb2k7OyAoKiBpbnN0 ZWFkIG9mIGxldCBwYXJzZSBzID0gR3JhbW1hci5FbnRyeS5wYXJzZSBleHBf ZW9pIChTdHJlYW0ub2Zfc3RyaW5nIHMpOzsgKikKCmV4Y2VwdGlvbiBOb1N1 Y2hUeXBlIG9mIHN0cmluZzs7CmxldCB0eV9vZl9zdHJpbmcgX2xvYyA9IGZ1 bmN0aW9uCiAgfCAiSW50IiAgLT4gYEludAogIHwgIlJlYWwiIC0+IGBSZWFs CiAgfCB0eSAgICAgLT4gTG9jLnJhaXNlIF9sb2MgKE5vU3VjaFR5cGUgdHkp Cjs7CmxldCBzdHJpbmdfb2ZfdHkgPSBmdW5jdGlvbgogIHwgYEludCAtPiAi SW50IgogIHwgYFJlYWwgLT4gIlJlYWwiCjs7CgooKiBUeXBlIENoZWNrZXIg KikKZXhjZXB0aW9uIFR5cGVFcnJvcjs7CnR5cGUgaW50ZWdlcj1bYEludF07 Owp0eXBlIHJlYWw9W2ludGVnZXIgfCBgUmVhbF07OwpsZXQgcmVjIHR5cGVf ZXhwcj1mdW5jdGlvbgogIHwgUEFwcChfbG9jLCBmLGFyZ3MpIC0+CiAgICAg IGJlZ2luIG1hdGNoIGYsIGFyZ3Mgd2l0aCAoKiBwYXR0ZXJuIG1hdGNoaW5n IGlzIHlvdXIgZnJpZW5kICopCiAgICAgIHwgImFkZCIsIFthcmcxOyBhcmcy XSAtPgogICAgICAgICAgKG1hdGNoIHR5cGVfZXhwciBhcmcxLCB0eXBlX2V4 cHIgYXJnMiB3aXRoCiAgICAgICAgICAgfCAjaW50ZWdlciwjaW50ZWdlciAt PiBgSW50CiAgICAgICAgICAgfCAjcmVhbCwjcmVhbCAtPiBgUmVhbCkKICAg ICAgfCBfIC0+IExvYy5yYWlzZSBfbG9jIFR5cGVFcnJvciAoKiBub3RlIHRo ZSBsb2NhdGlvbiB3cmFwcGluZyB0byBoYXZlIGEgY29ycmVjdCBsb2NhdGlv biAqKQogICAgICBlbmQKICB8IFBJbnQgXyAtPiBgSW50CiAgfCBQRmxvIF8g LT4gYFJlYWwKICB8IFBBbnQoX2xvYywgdHksIF8pIC0+IHR5X29mX3N0cmlu ZyBfbG9jIHR5Cjs7CgooKiBRdW90YXRpb25zICopCigqIG5vdGUgdGhhdCB0 aGlzIHR5cGUgZGVmaW5pdGlvbiB3aWxsIGJlIHVzZWZ1bCBvbmx5IGluIHBy b2dyYW1zIHRoYXQgd2lsbCB1c2UKICogPDpleHA8IC4uLiA+PiBidXQgbm90 IGhlcmUuICopCnR5cGUgYWxnID0KfCBBcHAgb2Ygc3RyaW5nKmFsZyBsaXN0 CnwgSW50IG9mIGludAp8IEZsbyBvZiBmbG9hdAphbmQgdHlwZWRfYWxnID0g KGFsZyAqIHJlYWwpCjs7CgpsZXQgdHlwZV9jaGVjayBfbG9jIChleHByLCB0 eV9leHByKSB0eSA9CiAgaWYgdHlfZXhwciA9IHR5IHRoZW4gZXhwcgogIGVs c2UgYmVnaW4KICAgIEZvcm1hdC5lcHJpbnRmICJAWzwyPkR5bmFtaWMgVHlw aW5nIEVycm9yIGF0QCAlYUBdQC4iIExvYy5wcmludCBfbG9jOwogICAgcmFp c2UgVHlwZUVycm9yCiAgZW5kCgpsZXQgZXhwcl9vZl9sb2MgbG9jID0gQ2Ft bHA0LlByZUNhc3QuQXN0Lk1ldGEuTWV0YUxvYy5tZXRhX2xvY19leHByIGxv YyBsb2M7OwoKbW9kdWxlIENhbWxTeW50YXggPQogIENhbWxwNE9DYW1sUGFy c2VyLk1ha2UoCiAgICBDYW1scDRPQ2FtbFJldmlzZWRQYXJzZXIuTWFrZSgK ICAgICAgQ2FtbHA0LlByZUNhc3QuU3ludGF4CiAgICApCiAgKTs7CmxldCBl eHByX29mX3N0cmluZyA9IENhbWxTeW50YXguR3JhbS5wYXJzZV9zdHJpbmcg Q2FtbFN5bnRheC5leHByX2VvaTs7CgpDYW1scDRfY29uZmlnLmFudGlxdW90 YXRpb25zIDo9IHRydWU7OyAoKiBUZWxsIGNhbWxwNCB0aGF0IHlvdSB3YW50 IHVzZSBhbnRpcXVvdGF0aW9ucyAqKQoKKCogT25lIGNhbm5vdCBleHBlY3Qg Z29vZCBsb2NhdGlvbnMgd2l0aCB0aGlzIGRlY2xhcmF0aW9uOiBsZXQgbG9j PVBsb2MuZHVtbXk7OyAqKQpsZXQgcmVjIHRvX2V4cHI9ZnVuY3Rpb24KICAg IHwgUEludChfbG9jLCB4KSAtPiA8OmV4cHI8IEludCAkaW50OngkID4+CiAg ICB8IFBGbG8oX2xvYywgeCkgLT4gPDpleHByPCBGbG8gJGZsbzp4JCA+Pgog ICAgfCBQQXBwKF9sb2MsIGYsIGVsKS0+CiAgICAgICAgbGV0IHJlYyBtYWtl X2VsPWZ1bmN0aW9uCiAgICAgICAgICAgIHwgeDo6eHMgLT4gPDpleHByPCAk eCQ6OiRtYWtlX2VsIHhzJCA+PgogICAgICAgICAgICAgICgqIGluc3RlYWQg b2YgPDpleHByPCBbJHgkOjokbWFrZV9lbCB4cyRdID4+IHNpbmNlIEkndmUg dXNlZCBjYW1scDRvZiAqKQogICAgICAgICAgICB8IFtdIC0+IDw6ZXhwcjwg W10gPj4KICAgICAgICBpbgogICAgICAgIGxldCBlbD1MaXN0Lm1hcCB0b19l eHByIGVsIGluCiAgICAgICAgbGV0IGVsPW1ha2VfZWwgZWwgaW4KICAgICAg ICA8OmV4cHI8IEFwcCAoJHN0cjpmJCwkZWwkKSA+PgogICAgfCBQQW50KF9s b2MsIHR5LCBzdHIpIC0+CiAgICAgICAgPDpleHByPCB0eXBlX2NoZWNrICRl eHByX29mX2xvYyBfbG9jJCAkZXhwcl9vZl9zdHJpbmcgX2xvYyBzdHIkIGAk dHkkID4+Cjs7CmxldCByZWMgdG9fcGF0dD1mdW5jdGlvbgogICAgfCBQSW50 KF9sb2MsIHgpIC0+IDw6cGF0dDwgSW50ICRpbnQ6eCQgPj4KICAgIHwgUEZs byhfbG9jLCB4KSAtPiA8OnBhdHQ8IEZsbyAkZmxvOngkID4+CiAgICB8IFBB cHAoX2xvYywgZiwgZWwpIC0+CiAgICAgICAgbGV0IHJlYyBtYWtlX2VsPWZ1 bmN0aW9uCiAgICAgICAgICAgIHwgeDo6eHMgLT4gPDpwYXR0PCAkeCQ6OiRt YWtlX2VsIHhzJCA+PgogICAgICAgICAgICB8IFtdIC0+IDw6cGF0dDwgW10g Pj4KICAgICAgICBpbgogICAgICAgIGxldCBlbD1MaXN0Lm1hcCB0b19wYXR0 IGVsIGluCiAgICAgICAgbGV0IGVsPW1ha2VfZWwgZWwgaW4KICAgICAgICA8 OnBhdHQ8IEFwcCAoJHN0cjpmJCwkZWwkKSA+PgogICAgfCBQQW50IF8gLT4g aW52YWxpZF9hcmcgImFudGlxdW90YXRpb25zIG5vdCBzdXBwb3J0ZWQgaW4g cGF0dGVybnMiCjs7CgpsZXQgZXhwYW5kX2V4cHIgX2xvYyBfbG9jX25hbWUg cyA9CiAgICBsZXQgcCA9IHBhcnNlIF9sb2MgcyBpbgogICAgbGV0IHQgPSB0 eXBlX2V4cHIgcCBpbgogICAgPDpleHByPCAoJHRvX2V4cHIgcCQsIGAkc3Ry aW5nX29mX3R5IHQkKSA+Pgo7OwpsZXQgZXhwYW5kX3BhdHQgX2xvYyBfbG9j X25hbWUgcyA9CiAgICBsZXQgcCA9IHBhcnNlIF9sb2MgcyBpbgogICAgbGV0 IHQgPSB0eXBlX2V4cHIgcCBpbgogICAgPDpwYXR0PCAoJHRvX3BhdHQgcCQs IGAkc3RyaW5nX29mX3R5IHQkKSA+Pgo7OwoKbGV0IGV4cGFuZF9zdHJfaXRl bSBsb2MgbG9jX25hbWUgcyA9CiAgPDpzdHJfaXRlbUBsb2M8ICRleHA6ZXhw YW5kX2V4cHIgbG9jIGxvY19uYW1lIHMkID4+Cgptb2R1bGUgUSA9IFN5bnRh eC5RdW90YXRpb247OwpRLmFkZCAiZXhwIiBRLkR5bkFzdC5leHByX3RhZyBl eHBhbmRfZXhwcjs7ClEuYWRkICJleHAiIFEuRHluQXN0LnBhdHRfdGFnIGV4 cGFuZF9wYXR0OzsKUS5hZGQgImV4cCIgUS5EeW5Bc3Quc3RyX2l0ZW1fdGFn IGV4cGFuZF9zdHJfaXRlbTs7Cg== --=-1197888854-252014-12227-6963-1-= Content-Disposition: attachment; filename="alg1_ant_test.ml" Content-Type: application/octet-stream; name="alg1_ant_test.ml" Content-Transfer-Encoding: base64 b3BlbiBBbGcxX2FudDs7CmxldCB4ID0gPDpleHA8IGFkZCgyMSwgMjEpID4+ IGluCmxldCB5ID0gPDpleHA8IGFkZCgzMSwgMTEuMCkgPj4gaW4KPDpleHA8 IGFkZChhZGQoJEludDogeCQsICRSZWFsOiB5JCksIDQyKSA+Pgo= --=-1197888854-252014-12227-6963-1-= Content-Disposition: attachment; filename="alg1_ant_str.ml" Content-Type: application/octet-stream; name="alg1_ant_str.ml" Content-Transfer-Encoding: base64 b3BlbiBDYW1scDQuUHJlQ2FzdDs7Cm1vZHVsZSBMb2MgPSBDYW1scDQuUHJl Q2FzdC5Mb2M7OwoKdHlwZSBwYWxnPQp8IFBBcHAgb2YgTG9jLnQgKiBzdHJp bmcgKiBwYWxnIGxpc3QgKCogaWYgeW91IHdhbnQgbG9jYXRpb25zLCB5b3Ug aGF2ZSB0byBrZWVwIHRoZW0gKikKfCBQSW50IG9mIExvYy50ICogc3RyaW5n CnwgUEZsbyBvZiBMb2MudCAqIHN0cmluZwp8IFBTdHIgb2YgTG9jLnQgKiBz dHJpbmcKfCBQQW50IG9mIExvYy50ICogc3RyaW5nICgqIHRoZSB0eXBlICop ICogc3RyaW5nICgqIHRoZSBleHByL3BhdHQgKikKOzsKCigqIFBhcnNlciAq KQptb2R1bGUgRyA9IE1ha2VHcmFtKExleGVyKTs7ICgqIGluc3RlYWQgb2Yg bGV0IGc9R3JhbW1hci5nY3JlYXRlIChQbGV4ZXIuZ21ha2UgKCkpOzsgKikK bGV0IGV4cF9lb2kgPSBHLkVudHJ5Lm1rICJleHBfZW9pIjs7ICgqIGluc3Rl YWQgb2YgR3JhbW1hci5FbnRyeS5jcmVhdGUgZyAiZXhwX2VvaSI7OyAqKQoK RVhURU5EIEcgKCogc3BlY2lmeSB3aGljaCBncmFtbWFyIHlvdSBleHRlbmQg KikKICBHTE9CQUw6IGV4cF9lb2k7CiAgZXhwX2VvaToKICAgIFtbIHggPSBl eHA7IGBFT0kgKCogYEVPSSBpbnN0ZWFkIG9mIEVPSSAqKSAtPiB4IF1dOwog IGV4cDoKICAgIFtbIHggPSBJTlQgLT4gUEludChfbG9jLCB4KQogICAgIHwg eCA9IEZMT0FUIC0+IFBGbG8oX2xvYywgeCkKICAgICB8IHggPSBTVFJJTkcg LT4gUFN0cihfbG9jLCB4KQogICAgIHwgZiA9IExJREVOVDsgIigiOyB4cyA9 IExJU1QxIFNFTEYgU0VQICIsIjsgIikiIC0+IFBBcHAoX2xvYywgZiwgeHMp CiAgICAgfCBgQU5USVFVT1QodHksIHN0cikgLT4gUEFudChfbG9jLCB0eSwg c3RyKSBdXTsKRU5EOzsKCmxldCBwYXJzZSA9IEcucGFyc2Vfc3RyaW5nIGV4 cF9lb2k7OyAoKiBpbnN0ZWFkIG9mIGxldCBwYXJzZSBzID0gR3JhbW1hci5F bnRyeS5wYXJzZSBleHBfZW9pIChTdHJlYW0ub2Zfc3RyaW5nIHMpOzsgKikK CmV4Y2VwdGlvbiBOb1N1Y2hUeXBlIG9mIHN0cmluZzs7CmxldCB0eV9vZl9z dHJpbmcgX2xvYyA9IGZ1bmN0aW9uCiAgfCAiSW50IiAgLT4gYEludAogIHwg IlJlYWwiIC0+IGBSZWFsCiAgfCAiU3RyIiAgLT4gYFN0cgogIHwgdHkgICAg IC0+IExvYy5yYWlzZSBfbG9jIChOb1N1Y2hUeXBlIHR5KQo7OwpsZXQgc3Ry aW5nX29mX3R5ID0gZnVuY3Rpb24KICB8IGBJbnQgLT4gIkludCIKICB8IGBS ZWFsIC0+ICJSZWFsIgogIHwgYFN0ciAtPiAiU3RyIgo7OwoKKCogVHlwZSBD aGVja2VyICopCmV4Y2VwdGlvbiBUeXBlRXJyb3I7Owp0eXBlIGludGVnZXI9 W2BJbnRdOzsKdHlwZSByZWFsPVtpbnRlZ2VyIHwgYFJlYWxdOzsKdHlwZSBh bnk9W3JlYWwgfCBgU3RyXTs7CmxldCByZWMgdHlwZV9leHByPWZ1bmN0aW9u CiAgfCBQQXBwKF9sb2MsIGYsYXJncykgLT4KICAgICAgYmVnaW4gbWF0Y2gg ZiwgYXJncyB3aXRoICgqIHBhdHRlcm4gbWF0Y2hpbmcgaXMgeW91ciBmcmll bmQgKikKICAgICAgfCAiYWRkIiwgW2FyZzE7IGFyZzJdIC0+CiAgICAgICAg ICAobWF0Y2ggdHlwZV9leHByIGFyZzEsIHR5cGVfZXhwciBhcmcyIHdpdGgK ICAgICAgICAgICB8ICNpbnRlZ2VyLCNpbnRlZ2VyIC0+IGBJbnQKICAgICAg ICAgICB8ICNyZWFsLCNyZWFsIC0+IGBSZWFsCiAgICAgICAgICAgfCAjYW55 LCNhbnkgLT4gTG9jLnJhaXNlIF9sb2MgVHlwZUVycm9yKQogICAgICB8IF8g LT4gTG9jLnJhaXNlIF9sb2MgVHlwZUVycm9yICgqIG5vdGUgdGhlIGxvY2F0 aW9uIHdyYXBwaW5nIHRvIGhhdmUgYSBjb3JyZWN0IGxvY2F0aW9uICopCiAg ICAgIGVuZAogIHwgUEludCBfIC0+IGBJbnQKICB8IFBGbG8gXyAtPiBgUmVh bAogIHwgUFN0ciBfIC0+IGBTdHIKICB8IFBBbnQoX2xvYywgdHksIF8pIC0+ IHR5X29mX3N0cmluZyBfbG9jIHR5Cjs7CgooKiBRdW90YXRpb25zICopCigq IG5vdGUgdGhhdCB0aGlzIHR5cGUgZGVmaW5pdGlvbiB3aWxsIGJlIHVzZWZ1 bCBvbmx5IGluIHByb2dyYW1zIHRoYXQgd2lsbCB1c2UKICogPDpleHA8IC4u LiA+PiBidXQgbm90IGhlcmUuICopCnR5cGUgYWxnID0KfCBBcHAgb2Ygc3Ry aW5nKmFsZyBsaXN0CnwgSW50IG9mIGludAp8IEZsbyBvZiBmbG9hdAp8IFN0 ciBvZiBzdHJpbmcKYW5kIHR5cGVkX2FsZyA9IChhbGcgKiBhbnkpCjs7Cgoo KiBEeW5hbWljIFR5cGUgQ2hlY2tlciAqKQpsZXQgdHlwZV9jaGVjayBfbG9j IChleHByLCB0eV9leHByKSB0eSA9CiAgaWYgdHlfZXhwciA9IHR5IHRoZW4g ZXhwcgogIGVsc2UgYmVnaW4KICAgIEZvcm1hdC5lcHJpbnRmICJAWzwyPkR5 bmFtaWMgVHlwaW5nIEVycm9yIGF0QCAlYUBdQC4iIExvYy5wcmludCBfbG9j OwogICAgcmFpc2UgVHlwZUVycm9yCiAgZW5kCgpsZXQgZXhwcl9vZl9sb2Mg bG9jID0gQ2FtbHA0LlByZUNhc3QuQXN0Lk1ldGEuTWV0YUxvYy5tZXRhX2xv Y19leHByIGxvYyBsb2M7OwoKbW9kdWxlIENhbWxTeW50YXggPQogIENhbWxw NE9DYW1sUGFyc2VyLk1ha2UoCiAgICBDYW1scDRPQ2FtbFJldmlzZWRQYXJz ZXIuTWFrZSgKICAgICAgQ2FtbHA0LlByZUNhc3QuU3ludGF4CiAgICApCiAg KTs7CmxldCBleHByX29mX3N0cmluZyA9IENhbWxTeW50YXguR3JhbS5wYXJz ZV9zdHJpbmcgQ2FtbFN5bnRheC5leHByX2VvaTs7CgpDYW1scDRfY29uZmln LmFudGlxdW90YXRpb25zIDo9IHRydWU7OyAoKiBUZWxsIGNhbWxwNCB0aGF0 IHlvdSB3YW50IHVzZSBhbnRpcXVvdGF0aW9ucyAqKQoKKCogT25lIGNhbm5v dCBleHBlY3QgZ29vZCBsb2NhdGlvbnMgd2l0aCB0aGlzIGRlY2xhcmF0aW9u OiBsZXQgbG9jPVBsb2MuZHVtbXk7OyAqKQpsZXQgcmVjIHRvX2V4cHI9ZnVu Y3Rpb24KICAgIHwgUEludChfbG9jLCB4KSAtPiA8OmV4cHI8IEludCAkaW50 OngkID4+CiAgICB8IFBGbG8oX2xvYywgeCkgLT4gPDpleHByPCBGbG8gJGZs bzp4JCA+PgogICAgfCBQU3RyKF9sb2MsIHgpIC0+IDw6ZXhwcjwgU3RyICRz dHI6eCQgPj4KICAgIHwgUEFwcChfbG9jLCBmLCBlbCktPgogICAgICAgIGxl dCByZWMgbWFrZV9lbD1mdW5jdGlvbgogICAgICAgICAgICB8IHg6OnhzIC0+ IDw6ZXhwcjwgJHgkOjokbWFrZV9lbCB4cyQgPj4KICAgICAgICAgICAgICAo KiBpbnN0ZWFkIG9mIDw6ZXhwcjwgWyR4JDo6JG1ha2VfZWwgeHMkXSA+PiBz aW5jZSBJJ3ZlIHVzZWQgY2FtbHA0b2YgKikKICAgICAgICAgICAgfCBbXSAt PiA8OmV4cHI8IFtdID4+CiAgICAgICAgaW4KICAgICAgICBsZXQgZWw9TGlz dC5tYXAgdG9fZXhwciBlbCBpbgogICAgICAgIGxldCBlbD1tYWtlX2VsIGVs IGluCiAgICAgICAgPDpleHByPCBBcHAgKCRzdHI6ZiQsJGVsJCkgPj4KICAg IHwgUEFudChfbG9jLCB0eSwgc3RyKSAtPgogICAgICAgIDw6ZXhwcjwgdHlw ZV9jaGVjayAkZXhwcl9vZl9sb2MgX2xvYyQgJGV4cHJfb2Zfc3RyaW5nIF9s b2Mgc3RyJCBgJHR5JCA+Pgo7OwpsZXQgcmVjIHRvX3BhdHQ9ZnVuY3Rpb24K ICAgIHwgUEludChfbG9jLCB4KSAtPiA8OnBhdHQ8IEludCAkaW50OngkID4+ CiAgICB8IFBGbG8oX2xvYywgeCkgLT4gPDpwYXR0PCBGbG8gJGZsbzp4JCA+ PgogICAgfCBQU3RyKF9sb2MsIHgpIC0+IDw6cGF0dDwgU3RyICRzdHI6eCQg Pj4KICAgIHwgUEFwcChfbG9jLCBmLCBlbCkgLT4KICAgICAgICBsZXQgcmVj IG1ha2VfZWw9ZnVuY3Rpb24KICAgICAgICAgICAgfCB4Ojp4cyAtPiA8OnBh dHQ8ICR4JDo6JG1ha2VfZWwgeHMkID4+CiAgICAgICAgICAgIHwgW10gLT4g PDpwYXR0PCBbXSA+PgogICAgICAgIGluCiAgICAgICAgbGV0IGVsPUxpc3Qu bWFwIHRvX3BhdHQgZWwgaW4KICAgICAgICBsZXQgZWw9bWFrZV9lbCBlbCBp bgogICAgICAgIDw6cGF0dDwgQXBwICgkc3RyOmYkLCRlbCQpID4+CiAgICB8 IFBBbnQgXyAtPiBpbnZhbGlkX2FyZyAiYW50aXF1b3RhdGlvbnMgbm90IHN1 cHBvcnRlZCBpbiBwYXR0ZXJucyIKOzsKCmxldCBleHBhbmRfZXhwciBfbG9j IF9sb2NfbmFtZSBzID0KICAgIGxldCBwID0gcGFyc2UgX2xvYyBzIGluCiAg ICBsZXQgdCA9IHR5cGVfZXhwciBwIGluCiAgICA8OmV4cHI8ICgkdG9fZXhw ciBwJCwgYCRzdHJpbmdfb2ZfdHkgdCQpID4+Cjs7CmxldCBleHBhbmRfcGF0 dCBfbG9jIF9sb2NfbmFtZSBzID0KICAgIGxldCBwID0gcGFyc2UgX2xvYyBz IGluCiAgICBsZXQgdCA9IHR5cGVfZXhwciBwIGluCiAgICA8OnBhdHQ8ICgk dG9fcGF0dCBwJCwgYCRzdHJpbmdfb2ZfdHkgdCQpID4+Cjs7CgpsZXQgZXhw YW5kX3N0cl9pdGVtIGxvYyBsb2NfbmFtZSBzID0KICA8OnN0cl9pdGVtQGxv YzwgJGV4cDpleHBhbmRfZXhwciBsb2MgbG9jX25hbWUgcyQgPj4KCm1vZHVs ZSBRID0gU3ludGF4LlF1b3RhdGlvbjs7ClEuYWRkICJleHAiIFEuRHluQXN0 LmV4cHJfdGFnIGV4cGFuZF9leHByOzsKUS5hZGQgImV4cCIgUS5EeW5Bc3Qu cGF0dF90YWcgZXhwYW5kX3BhdHQ7OwpRLmFkZCAiZXhwIiBRLkR5bkFzdC5z dHJfaXRlbV90YWcgZXhwYW5kX3N0cl9pdGVtOzsK --=-1197888854-252014-12227-6963-1-= Content-Disposition: attachment; filename="alg1_ant_test_bad.ml" Content-Type: application/octet-stream; name="alg1_ant_test_bad.ml" Content-Transfer-Encoding: base64 b3BlbiBBbGcxX2FudF9zdHI7OwpsZXQgeCA9IDw6ZXhwPCAiRk9PIiA+PiBp bgo8OmV4cDwgYWRkKDQyLCAkSW50OngkKSA+Pgo= --=-1197888854-252014-12227-6963-1-=--