diff --git a/CHANGES.md b/CHANGES.md index 4a32c382..46db9cff 100644 --- a/CHANGES.md +++ b/CHANGES.md @@ -2,6 +2,11 @@ ## Ongoing +- raise warning `atom(syntaxError)` when an execution, optimize, or preference + atom is malformed +- rename `forbid_warning` and `ignore_warning` to `warning_forbid` and + `warning_ignore`; allow an optional label argument for `warning_ignore` +- raise warning `statement(syntaxError)` when a statement is malformed - Use `bad` instead of `none` for set operator python evaluation - Update CI to run fewer smoke tests and to test only one configuration on routine commits. Enable caching for routine commit tests. @@ -19,7 +24,7 @@ `variable_declareOptional`, if unspecified, it defaults to the label of the corresponding `variable_declare` atom. - introduce optional label argument to `evaluate` -- raise warning `expression(syntax)` when an expression is malformed +- raise warning `expression(syntaxError)` when an expression is malformed - `evaluate` declarations now also generate expression-related warnings - Introduce warning `variable(badValue)` that is emitted when the value of some variable is bad diff --git a/docs/developer/fact-format.md b/docs/developer/fact-format.md index 11bf5f9c..6535b27f 100644 --- a/docs/developer/fact-format.md +++ b/docs/developer/fact-format.md @@ -151,9 +151,10 @@ This page describes the EBNF grammar for the fact format used by the constraint | "preference_variableValue" "(" "," "," "," ")" ::= - | "ignore_warning" "(" ")" - | "forbid_warning" "(" ")" - | "forbid_warning" "(" "," ")" + | "warning_forbid" "(" ")" + | "warning_forbid" "(" "," ")" + | "warning_ignore" "(" ")" + | "warning_ignore" "(" "," ")" ::= | "assign" "(" "," ")" diff --git a/docs/fact-format/fact-format.tex b/docs/fact-format/fact-format.tex index f7b263ac..f1a99bf8 100644 --- a/docs/fact-format/fact-format.tex +++ b/docs/fact-format/fact-format.tex @@ -155,9 +155,10 @@ \subsection{Building facts and declarations} \alt `preference_variableValue' `(' `,' `,' `,' `)' ::= -~\alt `ignore_warning' `(' `)' -\alt `forbid_warning' `(' `)' -\alt `forbid_warning' `(' `,' `)' +~\alt `warning_forbid' `(' `)' +\alt `warning_forbid' `(' `,' `)' +\alt `warning_ignore' `(' `)' +\alt `warning_ignore' `(' `,' `)' ::= ~\alt `assign' `(' `,' `)' diff --git a/docs/reference/error_handling.md b/docs/reference/error_handling.md index 7c6f9f30..77bca50e 100644 --- a/docs/reference/error_handling.md +++ b/docs/reference/error_handling.md @@ -75,10 +75,10 @@ warning(Type, Labels, Details) ## Ignore Warning **[Declaration]**{.badge .declaration } -Users have the option to ignore specific warnings by using the `ignore_warning/1` predicate. This allows users to suppress warnings that they are aware of and do not wish to be notified about. +Users have the option to ignore specific warnings by using the `warning_ignore/1` predicate. This allows users to suppress warnings that they are aware of and do not wish to be notified about. ```prolog -ignore_warning(WarningType) +warning_ignore(WarningType) ``` | Name | Description | @@ -89,7 +89,7 @@ ignore_warning(WarningType) To ignore warnings about variables with confusing names, you can use: ```prolog - ignore_warning(variable(confusingName)). + warning_ignore(variable(confusingName)). ``` This will suppress any warnings of the type `variable(confusingName)` from being reported in the future. @@ -99,13 +99,13 @@ ignore_warning(WarningType) ## Forbid Warning **[Declaration]**{.badge .declaration } **[Label Support]**{.badge .label-support } -Users can also choose to forbid specific warnings using the `forbid_warning/1` predicate. This means that if a forbidden warning is encountered, it will be treated as a failed constraint. +Users can also choose to forbid specific warnings using the `warning_forbid/1` predicate. This means that if a forbidden warning is encountered, it will be treated as a failed constraint. !!! Info Ignored warnings cannot be forbidden, and vice versa. If a warning type is both ignored and forbidden, it will be treated as ignored. ```prolog -forbid_warning(WarningType) +warning_forbid(WarningType) ``` | Name | Description | @@ -116,7 +116,7 @@ forbid_warning(WarningType) To forbid warnings about variables with empty domains, you can use: ```prolog - forbid_warning(variable(emptyDomain)). + warning_forbid(variable(emptyDomain)). ``` This will cause any warning of the type `variable(emptyDomain)` to be treated as an error, and it will prevent the model from being generated if such a warning is encountered. diff --git a/src/constraint_handler/data/atom.lp b/src/constraint_handler/data/atom.lp index 10823bbe..524d9275 100644 --- a/src/constraint_handler/data/atom.lp +++ b/src/constraint_handler/data/atom.lp @@ -55,57 +55,108 @@ optimize_maximizeSum(_label_anonymous,E,X,P) :- optimize_maximizeSum(E,X,P). optimize_maximizeSum(_label_anonymous,E,X,0) :- optimize_maximizeSum(E,X). %%%%%% preference atoms +#defined preference_holds/3. #defined preference_holds/2. #defined preference_holds/1. +#defined preference_variableValue/4. #defined preference_variableValue/3. #defined preference_variableValue/2. -preference_holds(_label_anonymous,E,K) :- preference_holds(E,K). -preference_variableValue(_label_anonymous,X,E,K) :- preference_variableValue(X,E,K). -%%% convenience -preference_holds(_label_anonymous,E,1) :- preference_holds(E). -preference_variableValue(_label_anonymous,X,E,1) :- preference_variableValue(X,E). +_passed(defaultArgs,preference_holds(LBL,E,K)) :- preference_holds(LBL,E,K). +_passed(defaultArgs,preference_holds(_label_anonymous,E,K)) :- preference_holds(E,K). +_passed(defaultArgs,preference_holds(_label_anonymous,E,1)) :- preference_holds(E). +_passed(defaultArgs,preference_variableValue(_label_anonymous,X,E,K)) :- preference_variableValue(X,E,K). +_passed(defaultArgs,preference_variableValue(LBL,X,E,K)) :- preference_variableValue(LBL,X,E,K). +_passed(defaultArgs,preference_variableValue(_label_anonymous,X,E,1)) :- preference_variableValue(X,E). %%%%%% warning atoms -#defined forbid_warning/1. -#defined ignore_warning/1. - -forbid_warning(_label_anonymous,KIND) :- forbid_warning(KIND). +#defined warning_forbid/1. +#defined warning_ignore/1. +warning_forbid(_label_anonymous,KIND) :- warning_forbid(KIND). +warning_ignore(_label_anonymous,KIND) :- warning_ignore(KIND). %%%%%%%%%%%%%%%%% collect labels -_label(LABEL) :- ensure(LABEL,_). -_label(LABEL) :- assign(LABEL,_,_). +_label(LABEL) :- ensure(LABEL,E). +_label(LABEL) :- assign(LABEL,X,E). _label(LABEL) :- define(LABEL,_,_,_). -_label(LABEL) :- evaluate(LABEL,_,_). +_label(LABEL) :- evaluate(LABEL,O,ARGS). %%%%%% variable atoms -_label(LABEL) :- variable_define(LABEL,_,_). -_label(LABEL) :- variable_declare(LABEL,_,_). -_label(LABEL) :- variable_domain(LABEL,_,_). +_label(LABEL) :- variable_define(LABEL,X,E). +_label(LABEL) :- variable_declare(LABEL,X,D). +_label(LABEL) :- variable_domain(LABEL,X,E). %%%%%% multimap atoms -_label(LABEL) :- multimap_declare(LABEL,_). -_label(LABEL) :- multimap_assign(LABEL,_,_,_). +_label(LABEL) :- multimap_declare(LABEL,X). +_label(LABEL) :- multimap_assign(LABEL,X,K,B). %%%%% set atoms -_label(LABEL) :- set_declare(LABEL,_). -_label(LABEL) :- set_assign(LABEL,_,_). -_label(LABEL) :- set_baseDomain(LABEL,_,_). +_label(LABEL) :- set_declare(LABEL,X). +_label(LABEL) :- set_assign(LABEL,X,E). +_label(LABEL) :- set_baseDomain(LABEL,X,E). %%%%%% statement atoms -_label(LABEL) :- execution_declare(LABEL,_,_,_,_). -_label(LABEL) :- execution_run(LABEL,_). +_label(LABEL) :- execution_declare(LABEL,NAME,STMT,INS,OUTS). +_label(LABEL) :- execution_run(LABEL,NAME). %%%%%% optimization atoms _label(LABEL) :- optimize_maximizeSum(LABEL,_,_,_). %%%%%% preference atoms -_label(LABEL) :- preference_holds(LABEL,_,_). -_label(LABEL) :- preference_variableValue(LABEL,_,_,_). +_label(LABEL) :- _passed(defaultArgs,preference_holds(LABEL,E,K)). +_label(LABEL) :- _passed(defaultArgs,preference_variableValue(LABEL,X,E,K)). %%%%%% warning atoms -_label(LABEL) :- forbid_warning(LABEL,_). +_label(LABEL) :- warning_forbid(LABEL,KIND). +_label(LABEL) :- warning_ignore(LABEL,KIND). %%%%%%%%%%%%%%%%% check if well-formed +_passed(sugar,ensure(LBL,E)) :- ensure(LBL,E), _expression_wellformed(E). +_passed(sugar,evaluate(LBL,OP,ARGS)) :- evaluate(LBL,OP,ARGS), _expression_wellformed(operation(OP,ARGS)). + + +_label(LABEL) :- define(LABEL,_,_,_). +%_passed(sugar,assign(LABEL,X,E)) :- assign(LABEL,X,E), _expression_wellformed(E). + + +%%%%%% multimap atoms +_passed(sugar,multimap_declare(LBL,X)) :- multimap_declare(LBL,X). +_passed(sugar,multimap_assign(LBL,X,K,B)) :- multimap_assign(LBL,X,K,B), _expression_wellformed(K), _expression_wellformed(B). + +%%%%% set atoms +_passed(sugar,set_declare(LBL,X)) :- set_declare(LBL,X). +_passed(sugar,set_assign(LBL,X,E)) :- set_assign(LBL,X,E), _expression_wellformed(E). +_passed(sugar,set_baseDomain(LBL,X,E)) :- set_baseDomain(LBL,X,E), _expression_wellformed(E). + +%%%%%% statement atoms +_passed(sugar,execution_declare(LBL,PRG,STMT,INS,OUTS)) :- execution_declare(LBL,PRG,STMT,INS,OUTS), + _statement_wellformed(STMT), + true=@pythonIsList(INS), + true=@pythonIsList(OUTS). +_passed(sugar,execution_run(LBL,PRG)) :- execution_run(LBL,PRG). +_warning(atom(syntaxError),(PRG,()),execution_declare(PRG)) :- execution_declare(LBL,PRG,STMT,INS,OUTS), + #false: _statement_wellformed(STMT), true=@pythonIsList(INS), true=@pythonIsList(OUTS). + +%%%%%% optimization atoms +_passed(sugar,optimize_maximizeSum(LBL,E,X,P)) :- optimize_maximizeSum(LBL,E,X,P), + _expression_wellformed(E), + (number,_,_,_)=@pythonReify(P). +_passed(sugar,optimize_precision(PREC,PRIO)) :- _passed(defaultArgs,optimize_precision(PREC,PRIO)), + _expression_wellformed(PREC), + (number,_,_,_)=@pythonReify(PRIO). +_warning(atom(syntaxError),(),optimize_maximizeSum(LBL,E,X,P)) :- optimize_maximizeSum(LBL,E,X,P), + not _passed(sugar,optimize_maximizeSum(LBL,E,X,P)). +_warning(atom(syntaxError),(),optimize_precision(PREC,PRIO)) :- optimize_precision(PREC,PRIO), + not _passed(sugar,optimize_precision(PREC,PRIO)). + +%%%%%% preference atoms +_passed(sugar,preference_holds(LABEL,E,K)) :- _passed(defaultArgs,preference_holds(LABEL,E,K)), _expression_wellformed(E), (number,_,_,_)=@pythonReify(K). +_passed(sugar,preference_variableValue(LABEL,X,E,K)) :- _passed(defaultArgs,preference_variableValue(LABEL,X,E,K)), _expression_wellformed(E), (number,_,_,_)=@pythonReify(K). +_passed(sugar,preference_expressionScore(LBL,operation(eq,(variable(X),(E,()))),K)) :- _passed(sugar,preference_variableValue(LBL,X,E,K)), K > 0. +_passed(sugar,preference_expressionScore(LBL,operation(neq,(variable(X),(E,()))),-K)) :- _passed(sugar,preference_variableValue(LBL,X,E,K)), K < 0. +_passed(sugar,preference_expressionScore(LBL,E,K)) :- _passed(sugar,preference_holds(LBL,E,K)), K > 0. +_passed(sugar,preference_expressionScore(LBL,operation(wnot,(E,())),-K)) :- _passed(sugar,preference_holds(LBL,E,K)), K < 0. + +%%%%%% warning atoms diff --git a/src/constraint_handler/data/bool.lp b/src/constraint_handler/data/bool.lp index 1979a368..61b95bc1 100644 --- a/src/constraint_handler/data/bool.lp +++ b/src/constraint_handler/data/bool.lp @@ -25,14 +25,14 @@ _operator_recoverable((conj;disj)). %_computedIdx(E,bool,true) :- _computeIdx(E,conj), E=operation(conj,L), _se_value(E1,val(bool,true)) : E1=@pythonListElements(L). _computedIdx(E,val(bool,false)) :- _computeIdx(E,conj), _computeIdx(E,IDX,val(bool,false)). _computedIdx(E,val(bool,true)) :- _computeIdx(E,conj), _computeIdx(E,IDX,val(bool,true)) : _computeIdx(E,IDX,V). -_computedIdx(E,bad) :- _computeIdx(E, conj), _computeIdx(E, _, bad), not _computedIdx(E, val(bool, false)). +_computedIdx(E,bad) :- _computeIdx(E,conj), _computeIdx(E,IDX,bad), not _computedIdx(E,val(bool,false)). %_se_value(E,val(bool,true)) :- direct_query(E), E=operation(conj,L), _se_value(E1,val(bool,true)) : E1=@pythonListElements(L). %_se_value(E,val(bool,false)) :- direct_query(E), E=operation(conj,L), _se_value(E1,val(bool,false)), E1=@pythonListElements(L). -_computedIdx(E,val(bool,true)) :- _computeIdx(E,disj), _computeIdx(E,_,val(bool,true)). +_computedIdx(E,val(bool,true)) :- _computeIdx(E,disj), _computeIdx(E,IDX,val(bool,true)). _computedIdx(E,val(bool,false)) :- _computeIdx(E,disj), _computeIdx(E,IDX,val(bool,false)) : _computeIdx(E,IDX,V). -_computedIdx(E,bad) :- _computeIdx(E, disj), _computeIdx(E, _, bad), not _computedIdx(E, val(bool, true)). +_computedIdx(E,bad) :- _computeIdx(E,disj), _computeIdx(E,IDX,bad), not _computedIdx(E,val(bool,true)). _operator_recoverable(limp). _computedIdx(E,val(bool,true)) :- _computeIdx(E,limp), _computeIdx(E,0,val(bool,false)). diff --git a/src/constraint_handler/data/conditionals.lp b/src/constraint_handler/data/conditionals.lp index d3c5d707..3411cbc1 100644 --- a/src/constraint_handler/data/conditionals.lp +++ b/src/constraint_handler/data/conditionals.lp @@ -6,22 +6,22 @@ conditional_hasNoValue(E) :- direct_query(E), _se_value(E,val(none,none)). %%%%%%%%%%%%%%%%% eq neq operator_declare((eq;neq),(T1,(T2,())),bool) :- _type(T1), _type(T2), (T1;T2)=none. _computedIdx(E,val(bool,true)) :- _computeIdx(E,eq), - _computeIdx(E,0,val(none,_)), - _computeIdx(E,1,val(none,_)). + _computeIdx(E,0,val(none,none)), + _computeIdx(E,1,val(none,none)). _computedIdx(E,val(bool,false)) :- _computeIdx(E,eq), - _computeIdx(E,0,val(T1,_)), - _computeIdx(E,1,val(T2,_)), - (T1;T2)=none, (T1;T2)!=none. + _computeIdx(E,0,val(T0,V0)), + _computeIdx(E,1,val(T1,V1)), + (T0;T1)=none, (T0;T1)!=none. _computedIdx(E,val(bool,false)) :- _computeIdx(E,neq), - _computeIdx(E,0,val(none,_)), - _computeIdx(E,1,val(none,_)). + _computeIdx(E,0,val(none,none)), + _computeIdx(E,1,val(none,none)). _computedIdx(E,val(bool,true)) :- _computeIdx(E,neq), - _computeIdx(E,0,val(T1,_)), - _computeIdx(E,1,val(T2,_)), - (T1;T2)=none, (T1;T2)!=none. + _computeIdx(E,0,val(T0,V0)), + _computeIdx(E,1,val(T1,V1)), + (T0;T1)=none, (T0;T1)!=none. %%%%%%%%%%%%%%%%% ite operator_declare(ite,(bool,(T,(T,()))),T) :- _type(T). diff --git a/src/constraint_handler/data/direct.lp b/src/constraint_handler/data/direct.lp index f5a1a35f..674e14cb 100644 --- a/src/constraint_handler/data/direct.lp +++ b/src/constraint_handler/data/direct.lp @@ -1,7 +1,7 @@ %%%%%%%%%%%%%%%%% interface ensure/2 assign/3 evaluate/2 -_se_ensure(CNAME,E) :- ensure(CNAME,E), engine(CNAME,compile). +_se_ensure(CNAME,E) :- _passed(sugar,ensure(CNAME,E)), engine(CNAME,compile). _se_assign(CNAME,variable(X),E) :- assign(CNAME,X,E), engine(CNAME,compile). -_se_evaluate(CNAME,OP,ARGS) :- evaluate(CNAME,OP,ARGS), engine(CNAME,compile). +_se_evaluate(CNAME,OP,ARGS) :- _passed(sugar,evaluate(CNAME,OP,ARGS)), engine(CNAME,compile). evaluated(OP,ARGS,V) :- _se_evaluate(CNAME,OP,ARGS), _se_value(operation(OP,ARGS),V). @@ -12,8 +12,8 @@ direct_query(X) :- _se_assign(NAME,X,E). direct_query(operation(OP,ARGS)) :- _se_evaluate(CNAME,OP,ARGS). direct_query(SE) :- direct_query(operation(OP,ES)), not _direct_lazy(OP), SE=@pythonListElements(ES). -_se_value(E,E) :- direct_query(E), E=val(_,_). -_se_value(E,E) :- direct_query(E), E=ref(_,_). +_se_value(val(T,V),val(T,V)) :- direct_query(val(T,V)). +_se_value(ref(T,R),ref(T,R)) :- direct_query(ref(T,R)). _se_value(lambda(VARS,ERES),val(function,lambda(VARS,ERES))) :- direct_query(lambda(VARS,ERES)). @@ -31,8 +31,8 @@ _se_value(E,VO) :- _direct_queryArgsValues(E,OP,ARGS), _computedIdx(E,VO). %%%%%%%%%%%%%%%%% lambda application -_direct_needs_args_list(E) :- _direct_queryArgsValues(E,lambda(_,_),_). -_length(ARGS,LEN) :- _direct_queryArgsValues(E,_,ARGS), LEN=@pythonListLength(ARGS). +_direct_needs_args_list(E) :- _direct_queryArgsValues(E,lambda(LARGS,SUB),ARGS). +_length(ARGS,LEN) :- _direct_queryArgsValues(E,OP,ARGS), LEN=@pythonListLength(ARGS). _direct_args_list_aux(E,IDX,()) :- _direct_needs_args_list(E), _length(ARGS,IDX). _direct_args_list_aux(E,IDX,(V,VS)) :- _direct_needs_args_list(E), _direct_args_list_aux(E,IDX+1,VS), _computeIdx(E,IDX,V). _direct_args_list(E,VS) :- _direct_needs_args_list(E), _direct_args_list_aux(E,0,VS). @@ -45,8 +45,8 @@ direct_query(RED) :- _lambda_aux(E,RED). _computedIdx(E,VO) :- _lambda_aux(E,RED), _se_value(RED,VO). %%%%%%%%%%%%%%%%% python operator -_direct_implode(V) :- _computeIdx(E,python(_)), _computeIdx(E,_,V). -_direct_imploded_args_aux(E,IDX,()) :- _direct_queryArgsValues(E,python(_),ARGS), _length(ARGS,IDX). +_direct_implode(V) :- _computeIdx(E,python(STR)), _computeIdx(E,IDX,V). +_direct_imploded_args_aux(E,IDX,()) :- _direct_queryArgsValues(E,python(STR),ARGS), _length(ARGS,IDX). _direct_imploded_args_aux(E,IDX,(IMP,L)) :- _direct_imploded_args_aux(E,IDX+1,L), _computeIdx(E,IDX,V), _direct_imploded(V,IMP). _expression_pythonEval(E,operation(python(S),L)) :- _computeIdx(E,python(S)), _direct_imploded_args_aux(E,0,L). @@ -72,8 +72,6 @@ _direct_imploded(val(T,V),val(T,V)) :- _direct_implode(val(T,V)), representation _direct_imploded(variable(X),V) :- _direct_implode(variable(X)), _se_value(variable(X),V). engine(_internal,compile). -%:- engine(NAME,E), not ensure(NAME,_), not assign(NAME,_,_). -%:- not engine(NAME,_), ensure(NAME,E). #external usc_relax(NAME) : engine(NAME,E). { usc_active(NAME) } :- engine(NAME,E). usc_active(NAME) :- engine(NAME,E), not usc_relax(NAME). diff --git a/src/constraint_handler/data/execution.lp b/src/constraint_handler/data/execution.lp index 9812d947..a3cc2c06 100644 --- a/src/constraint_handler/data/execution.lp +++ b/src/constraint_handler/data/execution.lp @@ -1,11 +1,11 @@ #defined _statement_query/2. %%%%%%%%%%%%%%%%% interface: execution_run/1 execution_assign/3 execution_output/4 execution_declare/3 -_execution_declare(NAME,STMT,INS,OUTS) :- execution_declare(CNAME,NAME,STMT,INS,OUTS), engine(CNAME,compile). +_execution_declare(NAME,STMT,INS,OUTS) :- _passed(sugar,execution_declare(LBL,NAME,STMT,INS,OUTS)), engine(LBL,compile). _execution_input_var(NAME,X) :- _execution_declare(NAME,STMT,INS,OUTS), X=@pythonListElements(INS). _execution_output_var(NAME,X) :- _execution_declare(NAME,STMT,INS,OUTS), X=@pythonListElements(OUTS). -_execution_run(NAME,STMT) :- _execution_declare(NAME,STMT,INS,OUTS), execution_run(CNAME,NAME), engine(CNAME,compile). -%_warning(("undeclared run",NAME)) :- execution_run(NAME), not execution_declare(_,NAME,_). +_execution_run(NAME,STMT) :- _execution_declare(NAME,STMT,INS,OUTS), _passed(sugar,execution_run(LBL,NAME)), engine(LBL,compile). +%_warning(("undeclared run",NAME)) :- _passed(sugar,execution_run(NAME)), not _passed(sugar,execution_declare(_,NAME,_)). _execution_in(NAME,X,V) :- _execution_run(NAME,STMT), _execution_input_var(NAME,X), _se_value(variable(execution_input(NAME,X)),V). @@ -69,8 +69,8 @@ _execution_fails(NAME,assert(EXPR)) :- _execution_run(NAME,assert(EXPR)), _execu %%%%%%%%%%%%%%%%% statement_python _direct_implode(V) :- _execution_run(NAME,statement_python(CODE)), _execution_in(NAME,X,V). _execution_mapAux(NAME,#inf,()) :- _execution_run(NAME,statement_python(STR)). -_execution_mapAux(NAME,Y,((Y,W),M)) :- _execution_mapAux(NAME,X,M), _execution_in(NAME,Y,V), X < Y, _direct_imploded(V,W), #false : _execution_in(NAME,Z,_), X < Z, Z < Y. -_execution_mapped(NAME,M) :- _execution_mapAux(NAME,X,M), #false : _execution_in(NAME,Y,_), X < Y. +_execution_mapAux(NAME,Y,((Y,W),M)) :- _execution_mapAux(NAME,X,M), _execution_in(NAME,Y,V), X < Y, _direct_imploded(V,W), #false : _execution_in(NAME,Z,VZ), X < Z, Z < Y. +_execution_mapped(NAME,M) :- _execution_mapAux(NAME,X,M), #false : _execution_in(NAME,Y,VY), X < Y. _execution_exec(NAME,R) :- _execution_run(NAME,statement_python(STR)), _execution_mapped(NAME,M), R=@pythonExec(statement_python(STR),M,ID), _main_solverIdentifier(ID). :- _execution_exec(NAME,failIntegrity). diff --git a/src/constraint_handler/data/expression.lp b/src/constraint_handler/data/expression.lp index 21ada764..b8d49126 100644 --- a/src/constraint_handler/data/expression.lp +++ b/src/constraint_handler/data/expression.lp @@ -1,15 +1,19 @@ -%%%%%%%%%%%%%%%%% _expression_query from evaluate -_expression_query((),operation(OP,ARGS)) :- evaluate(_,OP,ARGS). +%%%%%%%%%%%%%%%%% _expression_query from ensure evaluate +_expression_query((),E) :- ensure(LBL,E). +_expression_query((),operation(OP,ARGS)) :- evaluate(LBL,OP,ARGS). %%%%%%%%%%%%%%%%% _expression_query from variables -_expression_query((),E) :- variable_define(_,X,E). -_expression_query((),E) :- variable_domain(X,E). -_expression_query((),E) :- variable_declare(_,X,fromList(L)), E=@pythonListElements(L). +_expression_query((),E) :- variable_define(LBL,X,E). +_expression_query((),E) :- variable_domain(LBL,X,E). -_expression_query((),E) :- set_assign(_,X,E). -_expression_query((),E) :- set_baseDomain(_,X,E). -_expression_query((),K) :- multimap_assign(_,X,K,B). -_expression_query((),B) :- multimap_assign(_,X,K,B). +_expression_query((),E) :- set_assign(LBL,X,E). +_expression_query((),E) :- set_baseDomain(LBL,X,E). +_expression_query((),K) :- multimap_assign(LBL,X,K,B). +_expression_query((),B) :- multimap_assign(LBL,X,K,B). + +%%%%%%%%%%%%%%%%% _expression_query from other declarations +_expression_query((),E) :- optimize_maximizeSum(LBL,E,X,P). +_expression_query((),E) :- _passed(defaultArgs,optimize_precision(E,PRIO)). %%%%%%%%%%%%%%%%% _expression_query from expressions % TODO lambda?. @@ -30,6 +34,9 @@ _expression_poorlyformed(operation(O,L)) :- _expression_query(SCOPE,operation(O, _expression_poorlyformed(T) :- _expression_query(SCOPE,T), D=@pythonTupleElements(T), _expression_poorlyformed(D). _expression_wellformed(EXPR) :- _expression_query(SCOPE,EXPR), true=@pythonIsTuple(EXPR), not _expression_poorlyformed(EXPR). -_expression_wellformed(EXPR) :- _expression_query(SCOPE,EXPR), EXPR=operation(_,L), true=@pythonIsList(L), not _expression_poorlyformed(EXPR). +_expression_wellformed(EXPR) :- _expression_query(SCOPE,EXPR), EXPR=operation(O,L), true=@pythonIsList(L), not _expression_poorlyformed(EXPR). _warning(expression(syntaxError),SCOPE,EXPR) :- _expression_query(SCOPE,EXPR), not _expression_wellformed(EXPR). + +_expression_wellformed(lambda(ARGS,E)) :- _expression_query(SCOPE,lambda(ARGS,E)). +_warning(expression(syntaxError),SCOPE,"lambda checks unsupported") :- _expression_query(SCOPE,lambda(ARGS,E)). % TODO diff --git a/src/constraint_handler/data/gringoEval.lp b/src/constraint_handler/data/gringoEval.lp index 1d8ae038..6bc2ba32 100644 --- a/src/constraint_handler/data/gringoEval.lp +++ b/src/constraint_handler/data/gringoEval.lp @@ -1,11 +1,11 @@ %%%%%%%%%%%%%%%%% interface ensure/2 assign/3 evaluate/2 -_ge_ensure(CNAME,E) :- engine(CNAME,ground), ensure(CNAME,E). -_ge_assign(CNAME,X,E) :- engine(CNAME,ground), assign(CNAME,X,E). -_ge_set_assign(CNAME,X,E) :- engine(CNAME,ground), set_assign(CNAME,X,E). +_ge_ensure(CNAME,E) :- _passed(sugar,ensure(CNAME,E)), engine(CNAME,ground). +_ge_assign(CNAME,X,E) :- assign(CNAME,X,E), engine(CNAME,ground). +_ge_set_assign(CNAME,X,E) :- _passed(sugar,set_assign(CNAME,X,E)), engine(CNAME,ground). %%% TODO: handle set_baseDomain here? -_ge_set_declare(CNAME,X) :- engine(CNAME,ground), set_declare(CNAME,X). +_ge_set_declare(CNAME,X) :- _passed(sugar,set_declare(CNAME,X)), engine(CNAME,ground). %%% TODO: make sure set assign doesn't get broken down across different engines -_ge_evaluate(CNAME,OP,ARGS) :- engine(CNAME,ground), evaluate(CNAME,OP,ARGS). +_ge_evaluate(CNAME,OP,ARGS) :- _passed(sugar,evaluate(CNAME,OP,ARGS)), engine(CNAME,ground). :- _ge_ensure(CNAME,EXPR), not ge_result(EXPR,val(bool,true)), not ge_result(EXPR,bad). ge_value(X,V) :- _ge_assign(CNAME,X,EXPR), ge_result(EXPR,V). @@ -22,7 +22,7 @@ ge_expressionQuery(EXPR) :- _ge_assign(CNAME,X,EXPR). _ge_vQuery(X) :- ge_expressionQuery(EXPR), X=@pythonExpressionVariable(EXPR). -_direct_implode(variable(X)) :- _ge_vQuery(X), _se_value(variable(X),_). +_direct_implode(variable(X)) :- _ge_vQuery(X), _se_value(variable(X),V). ge_value(X,VAL) :- _ge_vQuery(X), _se_value(variable(X),val(T,V)), _direct_imploded(variable(X),VAL). @@ -41,5 +41,5 @@ _ge_mapAux(EXPR,I,((X,V),M)) :- _ge_mapAux(EXPR,I+1,M), _ge_enumeratedVariables( _ge_mapped(EXPR,M) :- _ge_mapAux(EXPR,0,M). _ge_eval_exec(EXPR,M,RES) :- _ge_mapped(EXPR,M), RES=@pythonEvalExpr(EXPR,M,ID), _main_solverIdentifier(ID). -ge_result(EXPR,V) :- _ge_eval_exec(EXPR,M,V), #false: V=error(_,_). +ge_result(EXPR,V) :- _ge_eval_exec(EXPR,M,V), #false: V=error(KIND,MSG). _warning(KIND,(),(EXPR,M,MSG)) :- _ge_eval_exec(EXPR,M,error(KIND,MSG)). diff --git a/src/constraint_handler/data/groundExec.lp b/src/constraint_handler/data/groundExec.lp index 5086a30d..b1aa07c0 100644 --- a/src/constraint_handler/data/groundExec.lp +++ b/src/constraint_handler/data/groundExec.lp @@ -1,6 +1,6 @@ %%%%%%%%%%%%%%%%% interface: execution_run/1 execution_assign/3 execution_output/4 execution_declare/3 -_gex_declare(NAME,STMT,INS,OUTS) :- execution_declare(CNAME,NAME,STMT,INS,OUTS), engine(CNAME,ground). -_gex_run(NAME,STMT,INS,OUTS) :- _gex_declare(NAME,STMT,INS,OUTS), execution_run(CNAME,NAME), engine(CNAME,ground). +_gex_declare(NAME,STMT,INS,OUTS) :- _passed(sugar,execution_declare(LBL,NAME,STMT,INS,OUTS)), engine(LBL,ground). +_gex_run(NAME,STMT,INS,OUTS) :- _gex_declare(NAME,STMT,INS,OUTS), _passed(sugar,execution_run(LBL,NAME)), engine(LBL,ground). _gex_inputVar(NAME,I,X,execution_input(NAME,X)) :- _gex_declare(NAME,STMT,INS,OUTS), (I,X)=@pythonEnumerateElements(INS). _gex_outputVar(NAME,X,execution_output(NAME,X)) :- _gex_declare(NAME,STMT,INS,OUTS), X=@pythonListElements(OUTS). diff --git a/src/constraint_handler/data/int.lp b/src/constraint_handler/data/int.lp index b76b352b..397194fc 100644 --- a/src/constraint_handler/data/int.lp +++ b/src/constraint_handler/data/int.lp @@ -6,7 +6,7 @@ _computedIdx(E,V) :- _computeIdx(E,add), _int_add(E,0,V). _computedIdx(operation(add,ARGS),val(int,N)) :- _computeIdx(operation(add,ARGS),add), _length(ARGS,LEN), LEN > 2, - LEN = #count { IDX : _computeIdx(operation(add,ARGS),IDX,val(int,_)) }, %%% TODO: remove + LEN = #count { IDX : _computeIdx(operation(add,ARGS),IDX,val(int,V)) }, %%% TODO: remove N = #sum { V,IDX : _computeIdx(operation(add,ARGS),IDX,val(int,V)) }. % short circuit if there is a 0 @@ -20,9 +20,9 @@ operator_declare((sub;pow),(int,(int,())),int). _operator_recoverable(pow). _computedIdx(E,val(int,V0-V1)) :- _computeIdx(E,sub), _computeIdx(E,0,val(int,V0)), _computeIdx(E,1,val(int,V1)). _computedIdx(E,val(int,V0**V1)) :- _computeIdx(E,pow), _computeIdx(E,0,val(int,V0)), _computeIdx(E,1,val(int,V1)). -_computedIdx(E,val(int,1)) :- _computeIdx(E,pow), _computeIdx(E,0,_), _computeIdx(E,1,val(int,0)). +_computedIdx(E,val(int,1)) :- _computeIdx(E,pow), _computeIdx(E,0,V0), _computeIdx(E,1,val(int,0)). _computedIdx(E,bad) :- _computeIdx(E,pow), _computeIdx(E,0,bad), _computeIdx(E,1,val(int,V1)), V1 != 0. -_computedIdx(E,bad) :- _computeIdx(E,pow), _computeIdx(E,0,_), _computeIdx(E,1,bad). +_computedIdx(E,bad) :- _computeIdx(E,pow), _computeIdx(E,0,V0), _computeIdx(E,1,bad). %%%%%%%%%%%%%%%%% int_div operator_declare(int_div,((int;float),((int;float),())),int). diff --git a/src/constraint_handler/data/main.lp b/src/constraint_handler/data/main.lp index 462237b5..00cb6bdb 100644 --- a/src/constraint_handler/data/main.lp +++ b/src/constraint_handler/data/main.lp @@ -27,5 +27,5 @@ value(X,V) :- _se_value(variable(X),V). representation((bool;int;string;float;symbol;none),extensional). -:- _warning(KIND,INFO,MSG), forbid_warning(NAME,KIND), not ignore_warning(KIND). -warning(KIND,INFO,MSG) :- _warning(KIND,INFO,MSG), not ignore_warning(KIND). +:- _warning(KIND,INFO,MSG), warning_forbid(LBL,KIND), not warning_ignore(_,KIND). +warning(KIND,INFO,MSG) :- _warning(KIND,INFO,MSG), not warning_ignore(_,KIND). diff --git a/src/constraint_handler/data/multimap.lp b/src/constraint_handler/data/multimap.lp index ff08f550..b1e85d4c 100644 --- a/src/constraint_handler/data/multimap.lp +++ b/src/constraint_handler/data/multimap.lp @@ -1,5 +1,5 @@ -_multimap_declare(CNAME,X) :- engine(CNAME,compile), multimap_declare(CNAME,X). -_multimap_assign(CNAME,variable(X),EK,EV) :- engine(CNAME,compile), multimap_assign(CNAME,X,EK,EV). +_multimap_declare(LBL,X) :- _passed(sugar,multimap_declare(LBL,X)), engine(LBL,compile). +_multimap_assign(LBL,variable(X),EK,EV) :- _passed(sugar,multimap_assign(LBL,X,EK,EV)), engine(LBL,compile). direct_query(EK;EV) :- _multimap_assign(CNAME,EX,EK,EV). @@ -82,16 +82,16 @@ direct_query(operation(eq,(X,(Y,())))) :- _computeIdx(E,eq), _computeIdx(E,0,val _multimap_entry(M2,K2,V2), (X,Y)=((K1,K2);(V1,V2)). -_computedIdx(E,val(bool,true)) :- _computeIdx(E,eq), _computeIdx(E,0,val(multimap,_)), _computeIdx(E,1,val(multimap,_)), +_computedIdx(E,val(bool,true)) :- _computeIdx(E,eq), _computeIdx(E,0,val(multimap,M0)), _computeIdx(E,1,val(multimap,M1)), not _computedIdx(E,val(bool,false)). -_computedIdx(E,val(bool,false)) :- _computeIdx(E,eq), _computeIdx(E,0,val(multimap,M1)), _computeIdx(E,1,val(multimap,M2)), - _multimap_entry(M1,K1,V1), - #false : _multimap_entry(M2,K2,V2), _se_value(operation(eq,(K1,(K2,()))),val(bool,true)), _se_value(operation(eq,(V1,(V2,()))),val(bool,true)). +_computedIdx(E,val(bool,false)) :- _computeIdx(E,eq), _computeIdx(E,0,val(multimap,M0)), _computeIdx(E,1,val(multimap,M1)), + _multimap_entry(M0,K0,V0), + #false : _multimap_entry(M1,K1,V1), _se_value(operation(eq,(K0,(K1,()))),val(bool,true)), _se_value(operation(eq,(V0,(V1,()))),val(bool,true)). -_computedIdx(E,val(bool,false)) :- _computeIdx(E,eq), _computeIdx(E,0,val(multimap,M1)), _computeIdx(E,1,val(multimap,M2)), - _multimap_entry(M2,K2,V2), - #false : _multimap_entry(M1,K1,V1), _se_value(operation(eq,(K1,(K2,()))),val(bool,true)), _se_value(operation(eq,(V1,(V2,()))),val(bool,true)). +_computedIdx(E,val(bool,false)) :- _computeIdx(E,eq), _computeIdx(E,0,val(multimap,M0)), _computeIdx(E,1,val(multimap,M1)), + _multimap_entry(M1,K1,V1), + #false : _multimap_entry(M0,K0,V0), _se_value(operation(eq,(K0,(K1,()))),val(bool,true)), _se_value(operation(eq,(V0,(V1,()))),val(bool,true)). %%%%%%%%%%%%%%%%%% Fold %%% fold: a -> b -> b @@ -99,9 +99,9 @@ _multimap_makeIndex(VM) :- _computeIdx(E,multimap_fold), _computeIdx(E,1,val(mul _multimap_foldStep(E,0,ACC) :- _computeIdx(E,multimap_fold), _computeIdx(E,2,ACC). direct_query(operation(VO,(VI,(VB,())))) :- _computeIdx(E,multimap_fold), _computeIdx(E,0,val(function,VO)), _computeIdx(E,1,val(multimap,VM)), - _multimap_index(VM,I,_,VI), _multimap_foldStep(E,I,VB). + _multimap_index(VM,I,KI,VI), _multimap_foldStep(E,I,VB). _multimap_foldStep(E,I+1,NEXT) :- _computeIdx(E,multimap_fold), _computeIdx(E,0,val(function,VO)), _computeIdx(E,1,val(multimap,VM)), - _multimap_foldStep(E,I,VB), _multimap_index(VM,I,_,VI), + _multimap_foldStep(E,I,VB), _multimap_index(VM,I,KI,VI), _se_value(operation(VO,(VI,(VB,()))),NEXT). _computedIdx(E,VB) :- _computeIdx(E, multimap_fold), _computeIdx(E,1,val(multimap,VM)), @@ -125,6 +125,6 @@ _multimap_lastIndex(EM,0) :- _multimap_makeIndex(EM), %%%%%%%%%%%%%%%%%% multimap_isin operator_declare(multimap_isin,(T1,(multimap,())),bool) :- _type(T1). _computedIdx(E,val(bool,true)) :- _computeIdx(E,multimap_isin), _computeIdx(E,0,K), _computeIdx(E,1,val(multimap,EM)), - _multimap_entry(EM,K,_). + _multimap_entry(EM,K,V). _computedIdx(E,val(bool,false)) :- _computeIdx(E,multimap_isin), _computeIdx(E,0,K), _computeIdx(E,1,val(multimap,EM)), - #false : _multimap_entry(EM,K,_). + #false : _multimap_entry(EM,K,V). diff --git a/src/constraint_handler/data/optimize.lp b/src/constraint_handler/data/optimize.lp index 82fb6c2f..483bbb40 100644 --- a/src/constraint_handler/data/optimize.lp +++ b/src/constraint_handler/data/optimize.lp @@ -1,12 +1,13 @@ % 4-parameter version with explicit priority -_optimize_maximizeSum(CNAME,E,X,P) :- optimize_maximizeSum(CNAME,E,X,P). +_optimize_maximizeSum(LBL,E,X,P) :- _passed(sugar,optimize_maximizeSum(LBL,E,X,P)). +_optimize_precision(PREC,PRIO) :- _passed(sugar,optimize_precision(PREC,PRIO)). -% Default precision for all priorities if not specified -_optimize_precision(PREC,P) :- optimize_precision(PREC), not optimize_precision(_,P), _optimize_maximizeSum(_,_,_,P). % Precision for specific priority (priority is last argument) -_optimize_precision(PREC,P) :- optimize_precision(PREC,P). +_passed(defaultArgs,optimize_precision(PREC,PRIO)) :- optimize_precision(PREC,PRIO). +% Default precision for all priorities if not specified +_passed(defaultArgs,optimize_precision(PREC,PRIO)) :- optimize_precision(PREC), not optimize_precision(_,PRIO), _optimize_maximizeSum(LBL,E,X,PRIO). % Default precision value of 1 if no precision is specified at all -_optimize_precision(val(int,1),P) :- _optimize_maximizeSum(_,_,_,P), not optimize_precision(_), not optimize_precision(_,P). +_passed(defaultArgs,optimize_precision(val(int,1),PRIO)) :- _optimize_maximizeSum(LBL,E,X,PRIO), not optimize_precision(_), not optimize_precision(_,PRIO). _optimize_se_maximizeSum(CNAME,E,X,P) :- _optimize_maximizeSum(CNAME,E,X,P), engine(CNAME,compile). diff --git a/src/constraint_handler/data/preference.lp b/src/constraint_handler/data/preference.lp index 2627541f..8001c9cd 100644 --- a/src/constraint_handler/data/preference.lp +++ b/src/constraint_handler/data/preference.lp @@ -3,11 +3,7 @@ _warning(preference(unsupported),(),("multiple scores for the same expression",E,K,L)) :- _preference_expressionScore(E,K), _preference_expressionScore(E,L), K < L. -_preference_expressionScore(operation(eq,(variable(X),(E,()))), K) :- preference_variableValue(CNAME,X,E,K), K > 0. -_preference_expressionScore(operation(wnot,(operation(eq,(variable(X),(E,()))),())),-K) :- preference_variableValue(CNAME,X,E,K), K < 0. - -_preference_expressionScore(E, K) :- preference_holds(CNAME,E,K), K > 0. -_preference_expressionScore(operation(wnot,(E,())),-K) :- preference_holds(CNAME,E,K), K < 0. +_preference_expressionScore(E,K) :- _passed(sugar,preference_expressionScore(LBL,E,K)), engine(LBL,compile). _preference_expression(E) :- _preference_expressionScore(E,K). direct_query(E) :- _preference_expression(E). diff --git a/src/constraint_handler/data/propagator.lp b/src/constraint_handler/data/propagator.lp index fbb5b5c2..9ef9f048 100644 --- a/src/constraint_handler/data/propagator.lp +++ b/src/constraint_handler/data/propagator.lp @@ -1,25 +1,26 @@ -propagator_ensure(CNAME,E) :- ensure(CNAME,E), engine(CNAME,propagator). +propagator_ensure(CNAME,E) :- _passed(sugar,ensure(CNAME,E)), engine(CNAME,propagator). propagator_assign(CNAME,X,E) :- assign(CNAME,X,E), engine(CNAME,propagator). -propagator_evaluate(CNAME,F,E) :- evaluate(CNAME,F,E), engine(CNAME,propagator). +propagator_evaluate(CNAME,F,E) :- _passed(sugar,evaluate(CNAME,F,E)), engine(CNAME,propagator). -propagator_variable_declare(CNAME,X,E) :- variable_declare(CNAME,X,E), engine(CNAME,propagator). -propagator_variable_declareOptional(CNAME,X) :- variable_declareOptional(CNAME,X), engine(CNAME,propagator). -propagator_variable_domain(CNAME,X,D) :- variable_domain(CNAME,X,D), engine(CNAME,propagator). -propagator_variable_define(CNAME,X,E) :- variable_define(CNAME,X,E), engine(CNAME,propagator). +propagator_variable_declare(CNAME,X,E) :- _passed(sugar,variable_declare(CNAME,X,E)), engine(CNAME,propagator). +propagator_variable_domain(CNAME,X,D) :- _passed(sugar,variable_domain(CNAME,X,D)), engine(CNAME,propagator). +propagator_variable_define(CNAME,X,E) :- _passed(sugar,variable_define(CNAME,X,E)), engine(CNAME,propagator). -propagator_set_assign(CNAME,X,E) :- set_assign(CNAME,X,E), engine(CNAME,propagator). -propagator_set_baseDomain(CNAME,X,E) :- set_baseDomain(CNAME,X,E), engine(CNAME,propagator). -propagator_set_declare(CNAME,X) :- set_declare(CNAME,X), engine(CNAME,propagator). +propagator_set_assign(CNAME,X,E) :- _passed(sugar,set_assign(CNAME,X,E)), engine(CNAME,propagator). +propagator_set_baseDomain(CNAME,X,E) :- _passed(sugar,set_baseDomain(CNAME,X,E)), engine(CNAME,propagator). +propagator_set_declare(CNAME,X) :- _passed(sugar,set_declare(CNAME,X)), engine(CNAME,propagator). -propagator_multimap_assign(CNAME,X,K,V) :- multimap_assign(CNAME,X,K,V), engine(CNAME,propagator). -propagator_multimap_declare(CNAME,X) :- multimap_declare(CNAME,X), engine(CNAME,propagator). +propagator_multimap_assign(LBL,X,K,V) :- _passed(sugar,multimap_assign(LBL,X,K,V)), engine(LBL,propagator). +propagator_multimap_declare(LBL,X) :- _passed(sugar,multimap_declare(LBL,X)), engine(LBL,propagator). -propagator_optimize_maximizeSum(CNAME,E,X,P) :- _optimize_maximizeSum(CNAME,E,X,P), engine(CNAME,propagator). +propagator_optimize_maximizeSum(LBL,E,X,P) :- _passed(sugar,optimize_maximizeSum(LBL,E,X,P)), engine(LBL,propagator). +propagator_optimize_precision(PREC,PRIO) :- _passed(sugar,optimize_precision(PREC,PRIO)), engine(LBL,propagator). -propagator_execution_declare(CNAME,F,STMT,IN,OUT) :- - execution_declare(CNAME,F,STMT,IN,OUT), engine(CNAME,propagator). +propagator_execution_declare(LBL,F,STMT,IN,OUT) :- + _passed(sugar,execution_declare(LBL,F,STMT,IN,OUT)), engine(LBL,propagator). -propagator_execution_run(CNAME,F) :- - execution_run(CNAME,F), engine(CNAME,propagator). +propagator_execution_run(LBL,F) :- + _passed(sugar,execution_run(LBL,F)), engine(LBL,propagator). -propagator_forbid_warning(CNAME,W) :- forbid_warning(CNAME,W), defaultEngine(propagator). +propagator_warning_forbid(LBL,W) :- warning_forbid(LBL,W), defaultEngine(propagator). +propagator_warning_ignore(LBL,W) :- warning_ignore(LBL,W), defaultEngine(propagator). diff --git a/src/constraint_handler/data/set.lp b/src/constraint_handler/data/set.lp index 03d70f86..b6de4165 100644 --- a/src/constraint_handler/data/set.lp +++ b/src/constraint_handler/data/set.lp @@ -1,5 +1,5 @@ -_set_assign(CNAME,variable(X),E) :- engine(CNAME,compile), set_assign(CNAME,X,E). -_set_declare(CNAME,variable(X)) :- engine(CNAME,compile), set_declare(CNAME,X). +_set_assign(CNAME,variable(X),E) :- _passed(sugar,set_assign(CNAME,X,E)), engine(CNAME,compile). +_set_declare(CNAME,variable(X)) :- _passed(sugar,set_declare(CNAME,X)), engine(CNAME,compile). direct_query(E) :- _set_assign(NAME,X,E). @@ -26,8 +26,8 @@ _set_assign(NAME,EX,S) :- _set_assign(NAME,EX,ref(set,S)). set_value(X,V) :- _se_value(variable(X),ref(set,E)), _set_contains(E,V). %%%%%%%%%%%%%%%%% set_baseDomain -{ set_assign(CNAME,X,E) } :- - set_baseDomain(CNAME,X,E), engine(CNAME,(compile;ground)). +{ set_assign(CNAME,X,E) } :- % TODO? + _passed(sugar,set_baseDomain(CNAME,X,E)), engine(CNAME,(compile;ground)). %%%%%%%%%%%%%%%%% set_isin set_notin operator_declare((set_isin;set_notin),(T1,(set,())),bool) :- _type(T1). @@ -97,8 +97,8 @@ _computedIdx(E,val(bool,NEQ)) :- _computeIdx(E,neq), _computeIdx(E,0,ARG0), _com _computedIdx(E,val(bool,true)) :- _computeIdx(E,eq), _computeIdx(E,0,ref(set,S1)), _computeIdx(E,1,ref(set,S2)), not _computedIdx(E,val(bool,false)). -_computedIdx(E,val(bool,false)) :- _computeIdx(E,eq), _computeIdx(E,0,ref(set,_)), _computeIdx(E,1,val(T2,_)), T2!=set. -_computedIdx(E,val(bool,false)) :- _computeIdx(E,eq), _computeIdx(E,0,val(T1,_)), _computeIdx(E,1,ref(set,_)), T1!=set. +_computedIdx(E,val(bool,false)) :- _computeIdx(E,eq), _computeIdx(E,0,ref(set,R)), _computeIdx(E,1,val(T1,V1)), T1!=set. +_computedIdx(E,val(bool,false)) :- _computeIdx(E,eq), _computeIdx(E,0,val(T0,V0)), _computeIdx(E,1,ref(set,V1)), T0!=set. _computedIdx(E,val(bool,false)) :- _computeIdx(E,eq), _computeIdx(E,0,ref(set,S1)), _computeIdx(E,1,ref(set,S2)), _set_contains(S1,V1), @@ -129,15 +129,15 @@ operator_declare(subset,(set,(set,())),bool). direct_query(operation(eq,(V1,(V2,())))) :- _computeIdx(E,subset), _computeIdx(E,0,ref(set,S1)), _computeIdx(E,1,ref(set,S2)), _set_contains(S1,V1), _set_contains(S2,V2). -_computedIdx(E,val(bool,false)) :- _computeIdx(E,subset), _computeIdx(E,0,ref(set,S1)), _computeIdx(E,1,ref(set,S2)), - _set_contains(S1,V1), - #false : _set_contains(S2,V2), _se_value(operation(eq,(V1,(V2,()))),val(bool,true)). +_computedIdx(E,val(bool,false)) :- _computeIdx(E,subset), _computeIdx(E,0,ref(set,S0)), _computeIdx(E,1,ref(set,S1)), + _set_contains(S0,V0), + #false : _set_contains(S1,V1), _se_value(operation(eq,(V0,(V1,()))),val(bool,true)). -_computedIdx(E,val(bool,true)) :- _computeIdx(E,subset), _computeIdx(E,0,ref(set,_)), _computeIdx(E,1,ref(set,_)), +_computedIdx(E,val(bool,true)) :- _computeIdx(E,subset), _computeIdx(E,0,ref(set,S0)), _computeIdx(E,1,ref(set,S1)), not _computedIdx(E,val(bool,false)). -_computedIdx(E,val(bool,false)) :- _computeIdx(E,subset), _computeIdx(E,0,val(T1,_)), _computeIdx(E,1,val(T2,_)), - (T1;T2) != set, (T1;T2) = set. +_computedIdx(E,val(bool,false)) :- _computeIdx(E,subset), _computeIdx(E,0,val(T0,V0)), _computeIdx(E,1,val(T1,V1)), + (T0;T1) != set, (T0;T1) = set. %%%%%%%%%%%%%%%%%% Fold %%% set_fold: a -> b -> b @@ -150,7 +150,7 @@ direct_query(operation(VO,(VI,(VB,())))) :- _computeIdx(E,set_fold), _computeIdx _set_foldStep(E,I+1,NEXT) :- _computeIdx(E,set_fold), _computeIdx(E,0,val(function,VO)), _computeIdx(E,1,ref(set,VM)), _set_foldStep(E,I,VB), _set_index(VM,I,VI), - _se_value(operation(VO,(VI,(VB,()))), NEXT). + _se_value(operation(VO,(VI,(VB,()))),NEXT). _computedIdx(E,VB) :- _computeIdx(E,set_fold), _computeIdx(E,1,ref(set,VM)), _set_foldStep(E,I,VB), _set_lastIndex(VM,I). diff --git a/src/constraint_handler/data/statement.lp b/src/constraint_handler/data/statement.lp new file mode 100644 index 00000000..fb7a0ca8 --- /dev/null +++ b/src/constraint_handler/data/statement.lp @@ -0,0 +1,10 @@ +%%%%%%%%%%%%%%%%% _statement_wellformed +_statement_wellformed(seq2(STM1,STM2)) :- _statement_query(SCOPE,seq2(STM1,STM2)), _statement_wellformed(STM1), _statement_wellformed(STM2). +_statement_wellformed(noop) :- _statement_query(SCOPE,noop). +_statement_wellformed(if(EXPR,THEN,ELSE)) :- _statement_query(SCOPE,if(EXPR,THEN,ELSE)), _expression_wellformed(EXPR), _statement_wellformed(THEN), _statement_wellformed(ELSE). +_statement_wellformed(assign(X,EXPR)) :- _statement_query(SCOPE,assign(X,EXPR)), _expression_wellformed(EXPR). +_statement_wellformed(assert(EXPR)) :- _statement_query(SCOPE,assert(EXPR)), _expression_wellformed(EXPR). +_statement_wellformed(statement_python(STR)) :- _statement_query(SCOPE,statement_python(STR)), (string,_,_,_)=@pythonReify(STR). +_statement_wellformed(while(MAX,EXPR,BODY)) :- _statement_query(SCOPE,while(MAX,EXPR,BODY)), _expression_wellformed(EXPR), _statement_wellformed(BODY). + +_warning(statement(syntaxError),SCOPE,STMT) :- _statement_query(SCOPE,STMT), not _statement_wellformed(STMT). diff --git a/src/constraint_handler/data/type.lp b/src/constraint_handler/data/type.lp index 225b2b23..1585b7b0 100644 --- a/src/constraint_handler/data/type.lp +++ b/src/constraint_handler/data/type.lp @@ -4,13 +4,10 @@ _type(int;float;bool;string;symbol;none;set;multimap). %%%%%%%%%%%%%%%%% type_variable -type_variable((),X,T) :- variable_define(_,X,D), type_expression((),D,T). -type_variable((),X,none) :- variable_declareOptional(X). -type_variable((),X,bool) :- variable_declare(_,X,boolDomain). -type_variable((),X,T) :- variable_declare(_,X,fromFacts), variable_domain(X,D), type_expression((),D,T). -type_variable((),X,T) :- variable_declare(_,X,fromList(L)), D=@pythonListElements(L), type_expression((),D,T). -type_variable((), X, set) :- set_declare(_, X). -type_variable((), X, multimap) :- multimap_declare(_, X). +type_variable((),X,T) :- _passed(sugar,variable_define(LBL,X,E)), type_expression((),E,T). +type_variable((),X,T) :- _passed(sugar,variable_domain(LBL,X,E)), type_expression((),E,T). +type_variable((),X,set) :- set_declare(LBL,X). +type_variable((),X,multimap) :- multimap_declare(LBL,X). %%%%%%%%%%%%%%%%% type_expression _expression_query((),E) :- type_query(E). @@ -18,9 +15,9 @@ type_expression(SCOPE,variable(X),T) :- _expression_query(SCOPE,variable(X)), ty type_expression(SCOPE,val(T,V),T) :- _expression_query(SCOPE,val(T,V)). type_expression(SCOPE,python(S),top) :- _expression_query(SCOPE,python(S)). type_expression(SCOPE,operation(O,ARGS),T) :- _expression_query(SCOPE,operation(O,ARGS)), _type_operator(SCOPE,O,function(TS,T)), _type_list(SCOPE,ARGS,TS). -type_expression(SCOPE, (H, T), (TH, TT)) :- _expression_query(SCOPE, (H, T)), type_expression(SCOPE, H, TH), type_expression(SCOPE, T, TT). +type_expression(SCOPE,(H,T),(TH,TT)) :- _expression_query(SCOPE,(H,T)), type_expression(SCOPE,H,TH), type_expression(SCOPE,T,TT). -_length(ARGS,N) :- _expression_query(SCOPE,operation(_,ARGS)), N=@pythonListLength(ARGS). +_length(ARGS,N) :- _expression_query(SCOPE,operation(O,ARGS)), N=@pythonListLength(ARGS). _type_listArg(SCOPE,ARGS,IDX,ARG) :- _expression_query(SCOPE,operation(O,ARGS)), (IDX,ARG)=@pythonEnumerateElements(ARGS). _type_listAux(SCOPE,ARGS,N,()) :- _expression_query(SCOPE,operation(O,ARGS)), _length(ARGS,N). _type_listAux(SCOPE,ARGS,N-1,(T,TS)) :- _type_listAux(SCOPE,ARGS,N,TS), _type_listArg(SCOPE,ARGS,N-1,ARG), type_expression(SCOPE,ARG,T). @@ -33,7 +30,8 @@ _type_list(SCOPE,ARGS,TS) :- _type_listAux(SCOPE,ARGS,0,TS). %%%%%%%%%%%%%%%%% type_statement % TODO statements. -_warning(type(failed_operation),(),(SCOPE,O,ARGS)) :- _expression_query(SCOPE,operation(O,ARGS)), not type_expression(SCOPE,operation(O,ARGS),_). +type_expressionTyped(SCOPE,operation(O,ARGS)) :- type_expression(SCOPE,operation(O,ARGS),T). +_warning(type(failed_operation),(),(SCOPE,O,ARGS)) :- _expression_query(SCOPE,operation(O,ARGS)), not type_expressionTyped(SCOPE,operation(O,ARGS)). %%%%%%%%%%%%%%%%% type_operator @@ -44,25 +42,25 @@ _type_operator((),O,function(TS,T)) :- operator_declare(O,TS,T). % - If the number of elements with a rank is equal to the number of arguments, % then all arguments were valid. % - If all elements were valid, the result with the highest rank will be picked as the return type -_arg_rank(SCOPE, OP, ARGS, IDX, RANK) :- - _type_listArg(SCOPE, ARGS, IDX, ARG), - type_expression(SCOPE, ARG, T), - operator_declare_variadic(OP, T, _, RANK). - -_valid_args_count(SCOPE, OP, ARGS, COUNT) :- - _expression_query(SCOPE, operation(OP, ARGS)), - COUNT = #count { IDX : _arg_rank(SCOPE, OP, ARGS, IDX, _) }. - -_max_rank(SCOPE, OP, ARGS, 1) :- - _valid_args_count(SCOPE, OP, ARGS, 0). - -_max_rank(SCOPE, OP, ARGS, MAXR) :- - _valid_args_count(SCOPE, OP, ARGS, C), C > 0, - MAXR = #max { RANK : _arg_rank(SCOPE, OP, ARGS, _, RANK) }. - -_type_operator(SCOPE, OP, function(TS, T_RESULT)) :- - _type_listAux(SCOPE, ARGS, N, ()), - _type_list(SCOPE, ARGS, TS), - _valid_args_count(SCOPE, OP, ARGS, N), - _max_rank(SCOPE, OP, ARGS, MAXR), - operator_declare_variadic(OP, _, T_RESULT, MAXR). +_arg_rank(SCOPE,OP,ARGS,IDX,RANK) :- + _type_listArg(SCOPE,ARGS,IDX,ARG), + type_expression(SCOPE,ARG,T), + operator_declare_variadic(OP,T,TRESULT,RANK). + +_valid_args_count(SCOPE,OP,ARGS,COUNT) :- + _expression_query(SCOPE,operation(OP,ARGS)), + COUNT = #count { IDX : _arg_rank(SCOPE,OP,ARGS,IDX,RANK) }. + +_max_rank(SCOPE,OP,ARGS,1) :- + _valid_args_count(SCOPE,OP,ARGS,0). + +_max_rank(SCOPE,OP,ARGS,MAXR) :- + _valid_args_count(SCOPE,OP,ARGS,C), C > 0, + MAXR = #max { RANK : _arg_rank(SCOPE,OP,ARGS,IDX,RANK) }. + +_type_operator(SCOPE,OP,function(TS,T_RESULT)) :- + _type_listAux(SCOPE,ARGS,N,()), + _type_list(SCOPE,ARGS,TS), + _valid_args_count(SCOPE,OP,ARGS,N), + _max_rank(SCOPE,OP,ARGS,MAXR), + operator_declare_variadic(OP,T,T_RESULT,MAXR). diff --git a/src/constraint_handler/data/variable.lp b/src/constraint_handler/data/variable.lp index 83e13deb..89b198a6 100644 --- a/src/constraint_handler/data/variable.lp +++ b/src/constraint_handler/data/variable.lp @@ -1,3 +1,19 @@ +%%%%%% syntactic sugar +_passed(sugar,variable_declare(LABEL,X,fromFacts)) :- variable_declare(LABEL,X,D), D=(fromFacts;boolDomain;fromList(L)). +_variable_tentativeDomain(LABEL,X,E) :- variable_domain(LABEL,X,E). +variable_domain(LABEL,X,E) :- variable_declare(LABEL,X,fromList(L)), E=@pythonListElements(L). +variable_domain(LABEL,X,val(bool,(false;true))) :- variable_declare(LABEL,X,boolDomain). +variable_domain(LABEL,X,val(none,none)) :- variable_declareOptional(LABEL,X). +_passed(sugar,variable_domain(LABEL,X,E)) :- variable_domain(LABEL,X,E), _expression_wellformed(E). +%_passed(sugar,variable_domain(LABEL,X,bad)) :- variable_domain(LABEL,X,E), not _expression_wellformed(E). % TODO + +_passed(sugar,variable_declare(LABEL,X,fromFacts)) :- variable_domain(LABEL,X,E), not variable_declare(_,X,_). +_warning(variable(undeclared),(),((),X)) :- variable_domain(LABEL,X,E), not variable_declare(_,X,_). + +_passed(sugar,variable_define(LABEL,X,E)) :- variable_define(LABEL,X,E), _expression_wellformed(E). +%_passed(sugar,variable_define(LABEL,X,bad)) :- variable_define(LABEL,X,E), not _expression_wellformed(E). % TODO + + _warning(variable(multipleDeclarations),(CNAME1,(CNAME2,())),(X,D1,D2)) :- variable_declare(CNAME1,X,D1), variable_declare(CNAME2,X,D2), (CNAME1,D1) < (CNAME2,D2), 0 = #count { CNAME3,D3 : variable_declare(CNAME3,X,D3), (CNAME3,D3) < (CNAME2,D2), (CNAME3,D3) != (CNAME1,D1) }. @@ -8,39 +24,35 @@ _warning(variable(multipleDefinitions),(CNAME1,(CNAME2,())),(X,E1,E2)) :- %%% rules for compile and ground engines -_variable_declare(CNAME,X,D) :- variable_declare(CNAME,X,D), engine(CNAME,(compile;ground)). -_variable_define(CNAME,X,E) :- variable_define(CNAME,X,E), engine(CNAME,(compile;ground)). +_variable_declare(CNAME,X,D) :- _passed(sugar,variable_declare(CNAME,X,D)), engine(CNAME,(compile;ground)). +_variable_define(CNAME,X,E) :- _passed(sugar,variable_define(CNAME,X,E)), engine(CNAME,(compile;ground)). assign(CNAME,X,E) :- _variable_define(CNAME,X,E). -_variable_domain(X,val(bool,(false;true))) :- _variable_declare(CNAME,X,boolDomain). -_variable_domain(X,V) :- _variable_declare(CNAME,X,fromList(L)), V=@pythonListElements(L). -_variable_domain(X,V) :- _variable_declare(CNAME,X,fromFacts), variable_domain(_,X,V). -_variable_domain(X,val(none,none)) :- variable_declareOptional(_,X), _variable_declare(CNAME,X,_). +_variable_domain(X,V) :- _passed(sugar,variable_domain(_,X,V)). _variable_hasDomain(X) :- _variable_domain(X,V). direct_query(E) :- _variable_domain(X,E). 1 { assign(CNAME,X,V) : _variable_domain(X,E), _se_value(E,V) } 1 :- - _variable_declare(CNAME,X,_), _variable_hasDomain(X). + _variable_declare(CNAME,X,D), _variable_hasDomain(X). -_warning(variable(emptyDomain),(CNAME,()),X) :- _variable_declare(CNAME,X,_), not _variable_hasDomain(X). +_warning(variable(emptyDomain),(CNAME,()),X) :- _variable_declare(CNAME,X,D), not _variable_hasDomain(X). %%%%%%%%%%%%%%%%% _variable_query -_variable_query((),X) :- variable_domain(X,V). +_variable_query((),X) :- _passed(sugar,variable_domain(LABEL,X,V)). _variable_query((),X) :- set_assign(NAME,X,E). _variable_query((),X) :- multimap_assign(NAME,X,K,B). _variable_query(SCOPE,X) :- _expression_query(SCOPE,variable(X)). _variable_query((),execution_input(NAME,X)) :- _statement_query(SCOPE,STMT), execution_declare(_,NAME,STMT,INS,OUTS), X=@pythonListElements(INS). -_variable_query((NAME,()),X) :- execution_declare(_,NAME,STMT,INS,OUTS), X=@pythonListElements(OUTS). +_variable_query((NAME,()),X) :- _passed(sugar,execution_declare(_,NAME,STMT,INS,OUTS)), X=@pythonListElements(OUTS). -_variable_exists((),X) :- variable_declare(_,X,_). -_variable_exists((),X) :- variable_define(_,X,_). -_variable_exists((),X) :- set_declare(_,X). -_variable_exists((),X) :- multimap_declare(_,X). -_variable_exists((),X) :- multimap_declare(_,X). +_variable_exists((),X) :- _passed(sugar,variable_declare(LBL,X,D)). +_variable_exists((),X) :- _passed(sugar,variable_define(LBL,X,E)). +_variable_exists((),X) :- _passed(sugar,set_declare(LBL,X)). +_variable_exists((),X) :- _passed(sugar,multimap_declare(LBL,X)). _variable_exists(SCOPE,X) :- _statement_query(SCOPE,assign(X,EXPR)). -_variable_exists((NAME,()),X) :- execution_declare(_,NAME,STMT,INS,OUTS), X=@pythonListElements(INS). -_variable_exists((),execution_output(NAME,X)) :- execution_declare(_,NAME,STMT,INS,OUTS), X=@pythonListElements(OUTS). +_variable_exists((NAME,()),X) :- _passed(sugar,execution_declare(LBL,NAME,STMT,INS,OUTS)), X=@pythonListElements(INS). +_variable_exists((),execution_output(NAME,X)) :- _passed(sugar,execution_declare(LBL,NAME,STMT,INS,OUTS)), X=@pythonListElements(OUTS). _variable_search_scope(SCOPE,X) :- _variable_query(SCOPE,X). _variable_search_scope(OUTER,X) :- _variable_search_scope(SCOPE,X), SCOPE=(_,OUTER), not _variable_exists(SCOPE,X). diff --git a/src/constraint_handler/evaluator.py b/src/constraint_handler/evaluator.py index d0a8d1b2..34e20f83 100644 --- a/src/constraint_handler/evaluator.py +++ b/src/constraint_handler/evaluator.py @@ -44,6 +44,8 @@ def collectVars(expr) -> frozenset[clingo.Symbol]: return frozenset.union(*(collectVars(e) for e in args)) if args else frozenset() case set(args) | frozenset(args): return frozenset.union(*(collectVars(e) for e in args)) if args else frozenset() + case expression.Bad.bad: + return frozenset() case _: print("collectVars", expr) assert False @@ -267,6 +269,8 @@ def expr(self, expr): return args case None: return None + case expression.Bad.bad: + return expr case _: self.errors.append( (warning.Expression(warning.ExpressionWarning.notImplemented), NotImplementedError(f"expr {expr}")) diff --git a/src/constraint_handler/main.py b/src/constraint_handler/main.py index d7c4abf4..65d78f0c 100644 --- a/src/constraint_handler/main.py +++ b/src/constraint_handler/main.py @@ -27,6 +27,7 @@ "propagator", "pythonHelper", "set", + "statement", "string", "symbol", "type", diff --git a/src/constraint_handler/propagator.py b/src/constraint_handler/propagator.py index 9f49be6c..d767e09a 100644 --- a/src/constraint_handler/propagator.py +++ b/src/constraint_handler/propagator.py @@ -1101,13 +1101,13 @@ def get_execution_declarations(self, ctl: clingo.PropagateInit): def get_forbidden_warnings(self, ctl: clingo.PropagateInit) -> None: """ - Load `forbid_warning` atoms. + Load `warning_forbid` atoms. Args: ctl: Clingo propagation initializer. """ - forbidden_warnings = myClorm.findInPropagateInit(ctl, warning.Forbid_warning) + forbidden_warnings = myClorm.findInPropagateInit(ctl, warning.Warning_forbid) for (name, error), literal in forbidden_warnings.items(): self.forbidden_warnings[error] = literal diff --git a/src/constraint_handler/schemas/atom.py b/src/constraint_handler/schemas/atom.py index b9630b3c..7d36495b 100644 --- a/src/constraint_handler/schemas/atom.py +++ b/src/constraint_handler/schemas/atom.py @@ -242,6 +242,10 @@ class Propagator_optimize_maximizeSum(Optimize_maximizeSum): pass +class Propagator_optimize_precision(Optimize_precision): + pass + + class Propagator_execution_declare(Execution_declare): pass @@ -254,5 +258,9 @@ class Propagator_evaluate(Evaluate): pass -class Propagator_forbid_warning(warning.Forbid_warning): +class Propagator_warning_forbid(warning.Warning_forbid): + pass + + +class Propagator_warning_ignore(warning.Warning_ignore): pass diff --git a/src/constraint_handler/schemas/warning.py b/src/constraint_handler/schemas/warning.py index 75815dcf..a660c14c 100644 --- a/src/constraint_handler/schemas/warning.py +++ b/src/constraint_handler/schemas/warning.py @@ -69,6 +69,11 @@ class Warning(typing.NamedTuple): info: typing.Any -class Forbid_warning(typing.NamedTuple): +class Warning_forbid(typing.NamedTuple): + label: typing.Any # expression.constant + symbol: Kind + + +class Warning_ignore(typing.NamedTuple): label: typing.Any # expression.constant symbol: Kind diff --git a/tests/example/lambdas.lp b/tests/example/lambdas.lp index 5923331e..59270a6c 100644 --- a/tests/example/lambdas.lp +++ b/tests/example/lambdas.lp @@ -72,3 +72,4 @@ variable_define(nb_squares2,E) :- #show value/2. #show _ge_eval_exec/3. +#show warning/3. diff --git a/tests/example/set_comparisons.lp b/tests/example/set_comparisons.lp index 4e3cd6fe..c77ffd33 100644 --- a/tests/example/set_comparisons.lp +++ b/tests/example/set_comparisons.lp @@ -1,14 +1,14 @@ set_declare(declared_set). -set_assign(declared_set, val(int,(1;2;3))). +set_assign(declared_set,val(int,(1;2;3))). -variable_define(made_set_1, operation(set_make, (val(int,1),(val(int,2),(val(int,3),()))))). -variable_define(made_set_2, operation(set_make, (val(int,1),(val(int,2),())))). +variable_define(made_set_1,operation(set_make,(val(int,1),(val(int,2),(val(int,3),()))))). +variable_define(made_set_2,operation(set_make,(val(int,1),(val(int,2),())))). -evaluate(eq, (variable(declared_set),(variable(made_set_1),()))). -evaluate(neq, (variable(declared_set),(variable(made_set_2),()))). +evaluate(eq,(variable(declared_set),(variable(made_set_1),()))). +evaluate(neq,(variable(declared_set),(variable(made_set_2),()))). -evaluate(eq, (variable(declared_set),(val(none,none),()))). -evaluate(neq, (val(none,none),(variable(declared_set),()))). +evaluate(eq,(variable(declared_set),(val(none,none),()))). +evaluate(neq,(val(none,none),(variable(declared_set),()))). -evaluate(eq, (variable(declared_set),(val(int,1),()))). -evaluate(neq, (val(int,1),(variable(declared_set),()))). +evaluate(eq,(variable(declared_set),(val(int,1),()))). +evaluate(neq,(val(int,1),(variable(declared_set),()))). diff --git a/tests/example/warning_bad.lp b/tests/example/warning_bad.lp index 58fd3154..55a49b32 100644 --- a/tests/example/warning_bad.lp +++ b/tests/example/warning_bad.lp @@ -3,7 +3,7 @@ variable_domain(a,val(int,0..1)). variable_define(b,operation(int_div,(val(int,6),(variable(a),())))). variable_define(p,operation(add,(variable(a),(variable(f),())))). -forbid_warning(variable(badValue)) :- doit. +warning_forbid(variable(badValue)) :- doit. { doit }. variable_define(f,val(int,10)) :- doit. variable_define(f,val(int,20)) :- not doit. diff --git a/tests/example/warning_python.lp b/tests/example/warning_python.lp index 5ae0fb48..e1f382a1 100644 --- a/tests/example/warning_python.lp +++ b/tests/example/warning_python.lp @@ -8,7 +8,7 @@ execution_declare(div0,statement_python("z = x/y\nassert 1.5 < z"),("x",("y",()) execution_run(div0). { activate }. -forbid_warning(statement(pythonError)) :- activate. +warning_forbid(statement(pythonError)) :- activate. variable_define(active,val(bool,true)) :- activate. variable_define(active,val(bool,false)) :- not activate. diff --git a/tests/example/warning_statement_malformed.expected.all b/tests/example/warning_statement_malformed.expected.all new file mode 100644 index 00000000..3e3c1818 --- /dev/null +++ b/tests/example/warning_statement_malformed.expected.all @@ -0,0 +1,20 @@ +warning(statement(syntaxError),(malformed_stmt_unknown,()),broken_statement) +warning(statement(syntaxError),(malformed_stmt_assign,()),assign(out,varrriable(x))) +warning(statement(syntaxError),(malformed_stmt_assert,()),assert(vaaal(int,1))) +warning(statement(syntaxError),(malformed_stmt_if_expr,()),if(varrriable(cond),noop,noop)) +warning(statement(syntaxError),(malformed_stmt_if_then,()),if(variable(cond),broken_then,noop)) +warning(statement(syntaxError),(malformed_stmt_if_then,()),broken_then) +warning(statement(syntaxError),(malformed_stmt_if_else,()),if(variable(cond),noop,broken_else)) +warning(statement(syntaxError),(malformed_stmt_if_else,()),broken_else) +warning(statement(syntaxError),(malformed_stmt_while_expr,()),while(5,varrriable(cond),noop)) +warning(statement(syntaxError),(malformed_stmt_while_body,()),while(5,variable(cond),broken_body)) +warning(statement(syntaxError),(malformed_stmt_while_body,()),broken_body) +warning(statement(syntaxError),(malformed_stmt_seq2,()),seq2(noop,broken_seq_part)) +warning(statement(syntaxError),(malformed_stmt_seq2,()),broken_seq_part) +warning(statement(syntaxError),(malformed_stmt_substmt_is_expression,()),seq2(noop,operation(add,(val(int,1),(val(int,2),()))))) +warning(statement(syntaxError),(malformed_stmt_substmt_is_expression,()),operation(add,(val(int,1),(val(int,2),())))) +warning(statement(syntaxError),(malformed_stmt_expr_is_statement,()),assign(out,noop)) +warning(statement(syntaxError),(malformed_stmt_python,()),statement_python(val(int,1))) +warning(atom(syntaxError),(malformed_decl_inputs_not_list,()),execution_declare(malformed_decl_inputs_not_list)) +warning(atom(syntaxError),(malformed_decl_outputs_not_list,()),execution_declare(malformed_decl_outputs_not_list)) +warning(atom(syntaxError),(malformed_decl_both_not_list,()),execution_declare(malformed_decl_both_not_list)) diff --git a/tests/example/warning_statement_malformed.expected.none b/tests/example/warning_statement_malformed.expected.none new file mode 100644 index 00000000..628676b3 --- /dev/null +++ b/tests/example/warning_statement_malformed.expected.none @@ -0,0 +1,4 @@ +warning(execution(syntaxError),(control_lists_ok,()),execution_declare(control_lists_ok,noop,(inp,()),(out,()))) +warning(statement(syntaxError),(control_nested_ok,()),assign(out,operation(add,(val(int,1),(val(int,2),()))))) +warning(statement(syntaxError),(control_nested_ok,()),statement_python("z=1")) +warning(statement(syntaxError),(control_nested_ok,()),if(operation(eq,(val(int,1),(val(int,1),()))),while(2,operation(lt,(val(int,0),(val(int,1),()))),seq2(assert(operation(eq,(val(int,3),(val(int,3),())))),statement_python("z=1"))),noop)) diff --git a/tests/example/warning_statement_malformed.lp b/tests/example/warning_statement_malformed.lp new file mode 100644 index 00000000..55b573c4 --- /dev/null +++ b/tests/example/warning_statement_malformed.lp @@ -0,0 +1,114 @@ +execution_declare(malformed_stmt_unknown,broken_statement,(),()). + +execution_declare(malformed_stmt_assign, + assign(out,varrriable(x)), + (), + (out,()) +). + +execution_declare(malformed_stmt_assert, + assert(vaaal(int,1)), + (), + () +). + +execution_declare(malformed_stmt_if_expr, + if(varrriable(cond),noop,noop), + (), + () +). + +execution_declare(malformed_stmt_if_then, + if(variable(cond),broken_then,noop), + (), + () +). + +execution_declare(malformed_stmt_if_else, + if(variable(cond),noop,broken_else), + (), + () +). + +execution_declare(malformed_stmt_while_expr, + while(5,varrriable(cond),noop), + (), + () +). + +execution_declare( + malformed_stmt_while_body, + while(5,variable(cond),broken_body), + (), + () +). + +execution_declare(malformed_stmt_seq2, + seq2(noop,broken_seq_part), + (), + () +). + +execution_declare(malformed_stmt_substmt_is_expression, + seq2(noop,operation(add,(val(int,1),(val(int,2),())))), + (), + () +). + +execution_declare(malformed_stmt_expr_is_statement, + assign(out,noop), + (), + (out,()) +). + +execution_declare(malformed_stmt_python, + statement_python(val(int,1)), + (), + () +). + +execution_declare(malformed_decl_inputs_not_list, + noop, + bad_inputs, + () +). + +execution_declare(malformed_decl_outputs_not_list, + noop, + (), + bad_outputs +). + +execution_declare(malformed_decl_both_not_list, + noop, + bad_inputs2, + bad_outputs2 +). + +execution_declare(control_lists_ok, + noop, + (inp,()), + (out,()) +). + +execution_declare(control_nested_ok, + seq2( + assign(out,operation(add,(val(int,1),(val(int,2),())))), + if( + operation(eq,(val(int,1),(val(int,1),()))), + while( + 2, + operation(lt,(val(int,0),(val(int,1),()))), + seq2( + assert(operation(eq,(val(int,3),(val(int,3),())))), + statement_python("z=1") + ) + ), + noop + ) + ), + (inp,()), + (out,(inp,())) +). + +#show warning/3. diff --git a/tests/test_encoding.py b/tests/test_encoding.py index 9cb21a58..6496b709 100644 --- a/tests/test_encoding.py +++ b/tests/test_encoding.py @@ -74,6 +74,7 @@ def run_test(name: str, engine: Literal["compile", "ground", "propagator"], chec "warning_bad", "warning_fake_forbid", "warning_python", + "warning_statement_malformed", "warning_syntax", "warning_type", "warning_variables",