package Ġcompiler . r ml . ast Ċ Ċ import Ġcompiler . pro log . ast .* Ċ Ċ val Ġdirectives : ĠList < Directive > Ġ= ĠlistOf ( ĊĠĠĠĠĠĠĠ Ġ// Ġ:- Ġmodule (' spec ', Ġ[ trace _ expression / 2 , Ġmatch / 2 ]). ĊĠĠĠĠĠĠĠ ĠDirective ( Compound Term (" module ", Ġatom (" spec "), ĠList Term ( ĊĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ ĠCompound Term ("/", Ġatom (" trace _ expression "), ĠInt Term ( 2 )), ĊĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ ĠCompound Term ("/", Ġatom (" match "), ĠInt Term ( 2 )) ĊĠĠĠĠĠĠĠ Ġ)) ), ĊĊĠĠĠĠĠĠĠ Ġ// Ġ:- Ġuse _ module ( monitor (' deep _ sub dict ')). ĊĠĠĠĠĠĠĠ ĠDirective ( Compound Term (" use _ module ", ĠCompound Term (" monitor ", Ġatom (" deep _ sub dict ")) )), ĊĊĠĠĠĠĠĠĠ Ġ// Ġ:- Ġuse _ module ( library (' cl pr ')). ĊĠĠĠĠĠĠĠ ĠDirective ( Compound Term (" use _ module ", ĠCompound Term (" library ", Ġatom (" cl pr ")) )) Ċ ) Ċ Ċ // Ġevent Ġtype Ġdeclarations Ġare Ġdirectly Ġcompiled Ġto ĠPro log Ċ // Ġthe Ġ 2 nd Ġargument Ġis Ġthe Ġfree Ġvariable Ġidentifier , Ġit Ġmust Ġnot Ġappear Ġin Ġthe Ġdeclaration Ċ fun Ġcompile ( declarations : ĠList < EventType Declaration >, ĠeventName : ĠString Ġ= Ġ"_ event ") Ġ= ĊĠĠĠĠĠĠĠ Ġdeclarations . flatMap Ġ{ Ġcompile ( it , ĠeventName ) Ġ} Ċ Ċ // Ġevent Ġtype Ġcompiler Ġ( inside Ġspecification Ġexpressions ) Ċ fun Ġcompile ( eventType : ĠEventType ): ĠCompound Term Ġ{ ĊĠĠĠ Ġ// Ġconvert Ġall Ġparameters , Ġwhether Ġthey Ġare Ġexpressions Ġor Ġvariables ĊĠĠĠ Ġval Ġparameters Ġ= ĠeventType . parameters . map Ġ{ Ġwhen Ġ( it ) Ġ{ ĊĠĠĠĠĠĠĠ Ġ// Ġevent Ġexpressions Ġare Ġnot Ġsupported Ġhere ĊĠĠĠĠĠĠĠ Ġis ĠEventType . Parameter . Event Expression Ġ-> Ġthrow ĠException (" unexpected Ġevent Ġexpression ") ĊĊĠĠĠĠĠĠĠ Ġ// Ġvariables Ġshould Ġbe Ġwrapped Ġas Ġvar ( x ) Ġinside Ġspecification Ġexpressions , Ġas Ġhere ĊĠĠĠĠĠĠĠ Ġis ĠEventType . Parameter . Variable Ġ-> ĠCompound Term (" var ", Ġatom ( it . variable . name )) ĊĊĠĠĠĠĠĠĠ Ġis ĠEventType . Parameter . Data Expression Ġ-> Ġcompile ( it . data Expression ) ĊĠĠĠ Ġ} Ġ} ĊĊĠĠĠ Ġreturn ĠCompound Term ( eventType . identifier . name , Ġparameters ) Ċ } Ċ Ċ // Ġdirectly Ġcompile Ġdata Ġexpressions Ġto ĠPro log Ċ fun Ġcompile ( data Expression : ĠData Expression , Ġwrap Variables : ĠBoolean Ġ= Ġtrue ): ĠTerm Ġ= Ġwhen Ġ( data Expression ) Ġ{ ĊĠĠĠ Ġis ĠBool Data Expression Ġ-> Ġatom ( data Expression . boolean . toString ()) ĊĠĠĠ Ġis ĠInt Data Expression Ġ-> ĠInt Term ( data Expression . int ) ĊĠĠĠ Ġis ĠFloat Data Expression Ġ-> ĠFloat Term ( data Expression . double ) ĊĠĠĠ Ġis ĠVariable Data Expression Ġ-> ĊĠĠĠĠĠĠĠ Ġif Ġ( wrap Variables ) ĠCompound Term (" var ", Ġatom ( data Expression . variable . name )) ĊĠĠĠĠĠĠĠ Ġelse ĠVariable Term ( data Expression . variable . name . capitalize ()) ĊĠĠĠ Ġis ĠMin us Data Expression Ġ-> ĠCompound Term ("- ", Ġcompile ( data Expression . exp , Ġwrap Variables )) ĊĠĠĠ Ġis ĠAbs Data Expression Ġ-> ĠCompound Term (" abs ", Ġcompile ( data Expression . exp , Ġwrap Variables )) ĊĊĠĠĠ Ġis ĠSin Data Expression Ġ-> ĠCompound Term (" sin ", Ġcompile ( data Expression . exp , Ġwrap Variables )) ĊĠĠĠ Ġis ĠCos Data Expression Ġ-> ĠCompound Term (" cos ", Ġcompile ( data Expression . exp , Ġwrap Variables )) ĊĠĠĠ Ġis ĠT an Data Expression Ġ-> ĠCompound Term (" tan ", Ġcompile ( data Expression . exp , Ġwrap Variables )) ĊĊĠĠĠ Ġis ĠSum Data Expression Ġ-> ĠCompound Term ("+ ", Ġcompile ( data Expression . left , Ġwrap Variables ), Ġcompile ( data Expression . right , Ġwrap Variables )) ĊĠĠĠ Ġis ĠSub Data Expression Ġ-> ĠCompound Term ("- ", Ġcompile ( data Expression . left , Ġwrap Variables ), Ġcompile ( data Expression . right , Ġwrap Variables )) ĊĠĠĠ Ġis ĠMul Data Expression Ġ-> ĠCompound Term ("* ", Ġcompile ( data Expression . left , Ġwrap Variables ), Ġcompile ( data Expression . right , Ġwrap Variables )) ĊĠĠĠ Ġis ĠDiv Data Expression Ġ-> ĠCompound Term ("/", Ġcompile ( data Expression . left , Ġwrap Variables ), Ġcompile ( data Expression . right , Ġwrap Variables )) ĊĠĠĠ Ġis ĠExp Data Expression Ġ-> ĠCompound Term ("^ ", Ġcompile ( data Expression . left , Ġwrap Variables ), Ġcompile ( data Expression . right , Ġwrap Variables )) ĊĠĠĠ Ġis ĠMax Data Expression Ġ-> ĠCompound Term (" max ", Ġcompile ( data Expression . left , Ġwrap Variables ), Ġcompile ( data Expression . right , Ġwrap Variables )) ĊĠĠĠ Ġis ĠMin Data Expression Ġ-> ĠCompound Term (" min ", Ġcompile ( data Expression . left , Ġwrap Variables ), Ġcompile ( data Expression . right , Ġwrap Variables )) ĊĠĠĠ Ġis ĠLess Than Data Expression Ġ-> ĠCompound Term ("< ", Ġcompile ( data Expression . left , Ġwrap Variables ), Ġcompile ( data Expression . right , Ġwrap Variables )) ĊĠĠĠ Ġis ĠLess Than Equal Data Expression Ġ-> ĠCompound Term (" =< ", Ġcompile ( data Expression . left , Ġwrap Variables ), Ġcompile ( data Expression . right , Ġwrap Variables )) ĊĠĠĠ Ġis ĠG reater Than Data Expression Ġ-> ĠCompound Term ("> ", Ġcompile ( data Expression . left , Ġwrap Variables ), Ġcompile ( data Expression . right , Ġwrap Variables )) ĊĠĠĠ Ġis ĠG reater Than Equal Data Expression Ġ-> ĠCompound Term ("> =", Ġcompile ( data Expression . left , Ġwrap Variables ), Ġcompile ( data Expression . right , Ġwrap Variables )) ĊĠĠĠ Ġis ĠEqual To Data Expression Ġ-> ĠCompound Term (" =: =", Ġcompile ( data Expression . left , Ġwrap Variables ), Ġcompile ( data Expression . right , Ġwrap Variables )) ĊĠĠĠ Ġis ĠNot EqualTo Data Expression Ġ-> ĠCompound Term (" = \\ =", Ġcompile ( data Expression . left , Ġwrap Variables ), Ġcompile ( data Expression . right , Ġwrap Variables )) ĊĠĠĠ Ġis ĠAnd Data Expression Ġ-> ĠCompound Term (",", Ġcompile ( data Expression . left , Ġwrap Variables ), Ġcompile ( data Expression . right , Ġwrap Variables )) ĊĠĠĠ Ġis ĠOr Data Expression Ġ-> ĠCompound Term (" ;", Ġcompile ( data Expression . left , Ġwrap Variables ), Ġcompile ( data Expression . right , Ġwrap Variables )) Ċ } Ċ Ċ private Ġfun Ġcompile ( declaration : ĠEventType Declaration , ĠeventName : ĠString Ġ= Ġ"_ event "): ĠList < Clause > Ġ{ ĊĠĠĠ Ġ// Ġonly Ġvariables Ġshould Ġappear Ġas Ġevent Ġtype Ġparameters ĊĠĠĠ Ġif Ġ( declaration . eventType . parameters . any Ġ{ Ġit Ġ! is ĠEventType . Parameter . Variable Ġ}) ĊĠĠĠĠĠĠĠ Ġthrow ĠException (" unexpected Ġexpression Ġin Ġevent Ġtype Ġparameters ") ĊĊĠĠĠ Ġval Ġparameters Ġ= Ġdeclaration . eventType . parameters . filter Is Instance < EventType . Parameter . Variable >() ĊĊĠĠĠ Ġ// Ġcheck Ġthe Ġvariable Ġidentifier Ġis Ġnot Ġused Ġin Ġarguments ĊĠĠĠ Ġif Ġ( parameters . map Ġ{ Ġit . variable . name Ġ}. contains ( eventName )) ĊĠĠĠĠĠĠĠ Ġthrow ĠException (" the Ġgiven Ġidentifier Ġfor Ġthe Ġevent Ġvariable Ġis Ġalready Ġin Ġuse ") ĊĊĠĠĠ Ġ// Ġmatch (_ event , ĠeventType ( X 1 , Ġ..., ĠX N )) ĊĠĠĠ Ġval Ġevent Variable Ġ= ĠVariable Term ( eventName ) ĊĠĠĠ Ġval ĠeventType Term Ġ= ĠCompound Term ( ĊĠĠĠĠĠĠĠĠĠĠĠ Ġdeclaration . eventType . identifier . name , ĊĠĠĠĠĠĠĠĠĠĠĠ Ġparameters . map Ġ{ ĠVariable Term ( it . variable . name . capitalize ()) Ġ}) ĊĠĠĠ Ġval Ġhead Ġ= ĠCompound Term (" match ", Ġevent Variable , ĠeventType Term ) ĊĊĠĠĠ Ġ// Ġgenerate Ġa Ġpredicate Ġfor Ġeach Ġparent Ġevent Ġtype Ġor Ġobject Ġpattern ĊĠĠĠ Ġval Ġparent Pred icates : ĠList < Term > Ġ= Ġwhen Ġ( declaration ) Ġ{ ĊĠĠĠĠĠĠĠ Ġ// Ġgenerate Ġa Ġdeep _ sub dict Ġ( matching ) Ġpredicate Ġfor Ġevery Ġpattern Ġinstantiation ĊĠĠĠĠĠĠĠ Ġis ĠDirect EventType Declaration Ġ-> Ġcompile ( declaration . event Expression ). map Ġ{ ĊĠĠĠĠĠĠĠĠĠĠĠ ĠCompound Term (" deep _ sub dict ", Ġit , Ġevent Variable ) ĊĠĠĠĠĠĠĠ Ġ}. toList () ĊĊĠĠĠĠĠĠĠ Ġ// Ġgenerate Ġa Ġmatch Ġpredicate Ġfor Ġevery Ġparent Ġevent Ġtype ĊĠĠĠĠĠĠĠ Ġis ĠDerived EventType Declaration Ġ-> Ġdeclaration . parents . map Ġ{ Ġparent EventType Ġ-> ĊĠĠĠĠĠĠĠĠĠĠĠ Ġval Ġparent Term Ġ= ĠCompound Term ( parent EventType . identifier . name , Ġparent EventType . parameters . map (:: compile )) ĊĠĠĠĠĠĠĠĠĠĠĠ ĠCompound Term (" match ", Ġevent Variable , Ġparent Term ) ĊĠĠĠĠĠĠĠ Ġ} ĊĠĠĠ Ġ} ĊĊĠĠĠ Ġ// Ġwith Ġdata Ġexpression ĊĠĠĠ Ġval Ġguard Predicate : ĠConstraint Term ? Ġ= ĠĊĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġ( declaration . with Data Expression Ġ!= Ġnull ) ĊĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ ĠConstraint Term ( compile ( declaration . with Data Expression !! , Ġwrap Variables Ġ= Ġfalse )) ĠĊĠĠĠĠĠĠĠĠĠĠĠ Ġelse Ġnull ĊĊĠĠĠ Ġ// Ġif Ġnot Ġneg ated , Ġjust Ġgenerate Ġa Ġclause Ġfor Ġevery Ġpredicate ĊĠĠĠ Ġif Ġ(! declaration . neg ated ) ĊĠĠĠĠĠĠĠ Ġreturn Ġparent Pred icates . map Ġ{ ĠClause ( head , ĠlistOf ( it ) Ġ+ ĠlistOf NotNull ( guard Predicate )) Ġ} ĊĊĠĠĠ Ġ// Ġotherwise Ġjust Ġgenerate Ġone Ġclause Ġwith Ġall Ġthe Ġneg ated Ġpredicates Ġin Ġthe Ġbody ĊĠĠĠ Ġreturn ĠlistOf ( Clause ( head , Ġparent Pred icates . map Ġ{ ĠCompound Term (" not ", Ġit ) Ġ} Ġ+ ĠlistOf NotNull ( guard Predicate ))) Ċ } Ċ Ċ private Ġfun Ġcompile ( parameter : ĠEventType . Parameter ): ĠTerm Ġ= Ġwhen Ġ( parameter ) Ġ{ ĊĠĠĠ Ġis ĠEventType . Parameter . Data Expression Ġ-> Ġcompile ( parameter . data Expression , Ġwrap Variables Ġ= Ġfalse ) ĊĠĠĠ Ġis ĠEventType . Parameter . Event Expression Ġ-> Ġ{ ĊĠĠĠĠĠĠĠ Ġ// Ġno Ġpatterns Ġexpected Ġhere ĊĠĠĠĠĠĠĠ Ġval Ġresult Ġ= Ġcompile ( parameter . event Expression ). toList () ĊĠĠĠĠĠĠĠ Ġif Ġ( result . size Ġ> Ġ 1 ) ĊĠĠĠĠĠĠĠĠĠĠĠ Ġthrow ĠException (" unexpected Ġevent Ġpattern Ġin Ġparameter ") ĊĠĠĠĠĠĠĠ Ġresult . single () ĊĠĠĠ Ġ} ĊĠĠĠ Ġis ĠEventType . Parameter . Variable Ġ-> ĠVariable Term ( parameter . variable . name . capitalize ()) Ċ } Ċ Ċ private Ġfun Ġcompile ( event Expression : ĠEvent Expression ): ĠSequence < Term > Ġ= Ġsequence Ġ{ ĊĠĠĠ Ġwhen Ġ( event Expression ) Ġ{ ĊĠĠĠĠĠĠĠ ĠIgnore d Event Expression Ġ-> Ġyield ( Variable Term ("_ ")) ĊĠĠĠĠĠĠĠ Ġis ĠPattern Event Expression Ġ-> Ġ{ ĊĠĠĠĠĠĠĠĠĠĠĠ Ġyield All ( compile ( event Expression . left )) ĊĠĠĠĠĠĠĠĠĠĠĠ Ġyield All ( compile ( event Expression . right )) ĊĠĠĠĠĠĠĠ Ġ} ĊĠĠĠĠĠĠĠ Ġis ĠList Event Expression Ġ-> Ġcompile List Event Expression ( event Expression . list ). forEach Ġ{ ĊĠĠĠĠĠĠĠĠĠĠĠ Ġyield ( List Term ( it , Ġevent Expression . more Allowed )) ĊĠĠĠĠĠĠĠ Ġ} ĊĠĠĠĠĠĠĠ Ġis ĠString Event Expression Ġ-> Ġyield ( String Term ( event Expression . string )) ĊĠĠĠĠĠĠĠ Ġis ĠInt Event Expression Ġ-> Ġyield ( Int Term ( event Expression . number )) ĊĠĠĠĠĠĠĠ Ġis ĠFloat Event Expression Ġ-> Ġyield ( Float Term ( event Expression . number )) ĊĠĠĠĠĠĠĠ Ġis ĠBool Event Expression Ġ-> Ġyield ( atom ( event Expression . value . toString ())) ĊĠĠĠĠĠĠĠ Ġis ĠVariable Event Expression Ġ-> Ġyield ( Variable Term ( event Expression . variable . name . capitalize ())) ĊĠĠĠĠĠĠĠ Ġis ĠObject Event Expression Ġ-> Ġyield All ( compile ( event Expression )) ĊĠĠĠ Ġ} Ċ } Ċ Ċ // Ġrecursively Ġwork Ġon Ġthe Ġlist Ċ private Ġfun Ġcompile List Event Expression ( list : ĠList < Event Expression >): ĠSequence < List < Term >> Ġ= Ġsequence Ġ{ ĊĠĠĠ Ġif Ġ( list . isEmpty ()) Ġyield ( emptyList ()) ĊĠĠĠ Ġelse Ġ{ ĊĠĠĠĠĠĠĠ Ġcompile ( list . first ()). forEach Ġ{ Ġhead Ġ-> ĊĠĠĠĠĠĠĠĠĠĠĠ Ġcompile List Event Expression ( list . drop ( 1 )). forEach Ġ{ Ġtail Ġ-> ĊĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġyield ( listOf ( head ) Ġ+ Ġtail ) ĊĠĠĠĠĠĠĠĠĠĠĠ Ġ} ĊĠĠĠĠĠĠĠ Ġ} ĊĠĠĠ Ġ} Ċ } Ċ Ċ private Ġfun Ġcompile ( object Expression : ĠObject Event Expression ): ĠSequence < Dictionary Term > Ġ= Ġsequence Ġ{ ĊĠĠĠ Ġif Ġ( object Expression . fields . isEmpty ()) ĊĠĠĠĠĠĠĠ Ġyield ( Dictionary Term ( Variable Term ("_ "), Ġempty List ())) ĊĠĠĠ Ġelse Ġ{ ĊĠĠĠĠĠĠĠ Ġval Ġfirst Field Ġ= Ġobject Expression . fields . first () ĊĠĠĠĠĠĠĠ Ġval Ġother Fields Ġ= Ġobject Expression . fields . drop ( 1 ) ĊĊĠĠĠĠĠĠĠ Ġ// Ġfirst Ġexpand Ġthe Ġvalue Ġof Ġthe Ġfirst Ġfield ĊĠĠĠĠĠĠĠ Ġcompile ( first Field . value ). forEach Ġ{ Ġvalue Term Ġ-> ĊĠĠĠĠĠĠĠĠĠĠĠ Ġ// Ġthen Ġcompile Ġand Ġexpand Ġan Ġobject Ġmade Ġfrom Ġall Ġthe Ġother Ġfields ĊĠĠĠĠĠĠĠĠĠĠĠ Ġval Ġother Fields Object Ġ= ĠObject Event Expression ( other Fields ) ĊĠĠĠĠĠĠĠĠĠĠĠ Ġcompile ( other Fields Object ). forEach Ġ{ Ġobject Term Ġ-> ĊĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġ// Ġnow Ġcombine Ġthe Ġresult ĊĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġval Ġfirst KeyValuePair Ġ= ĠDictionary Term . KeyValuePair ( atom ( first Field . key . name ), Ġvalue Term ) ĊĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġyield ( Dictionary Term ( Variable Term ("_ "), ĠlistOf ( first KeyValuePair ) Ġ+ Ġobject Term . pairs )) ĊĠĠĠĠĠĠĠĠĠĠĠ Ġ} ĊĠĠĠĠĠĠĠ Ġ} ĊĠĠĠ Ġ} Ċ }