/* le_input: a prolog module with predicates to translate from an extended version of Logical English into the Prolog or Taxlogtemplate_decl http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Main predicate: text_to_logic(String to be translated, Translation) Main DCG nonterminal: document(Translation) See at the end the predicate le_taxlog_translate to be used from SWISH It assumes an entry with the following structure. One of these expressions: the meta predicates are: the predicates are: the templates are: the timeless predicates are: the event predicates are: the fluents are: the time-varying predicates are: followed by the declarations of all the corresponding predicates mentioned in the knowledge base. Each declarations define a template with the variables and other words required to describe a relevant relation. It is a comma separated list of templates which ends with a period. After that period, one of the following statement introduces the knowledge base: the knowledge base includes: the knowledge base includes: And it is followed by the rules and facts written in Logical English syntax. Each rule must end with a period. Indentation is used to organize the and/or list of conditions by strict observance of one condition per line with a level of indentation that corresponds to each operator and corresponding conditions. Similarly, there may be sections for scenarios and queries, like: -- scenario test2 is: borrower pays an amount to lender on 2015-06-01T00:00:00. -- and -- query one is: for which event: the small business restructure rollover applies to the event. query two is: which tax payer is a party of which event. query three is: A first time is after a second time and the second time is immediately before the first time. -- which can then be used on the new command interface of LE on SWISH (e.g. answer/1 and others querying predicates): ? answer("query one with scenario test"). */ :- module(le_input, [document/3, le_taxlog_translate/4, text_to_logic/2, predicate_decl/4, op(1000,xfy,user:and), % to support querying op(800,fx,user:resolve), % to support querying op(800,fx,user:answer), % to support querying op(800,fx,user:répondre), % to support querying in french op(850,xfx,user:with), % to support querying op(850,xfx,user:avec), % to support querying in french op(800,fx,user:risposta), % to support querying in italian op(850,xfx,user:con), % to support querying in italian op(800,fx,user:responde), % to support querying in spanish %op(1150,fx,user:show), % to support querying op(850,xfx,user:of), % to support querying %op(850,fx,user:'#pred'), % to support scasp %op(800,xfx,user:'::'), % to support scasp op(950, xfx, ::), % pred not x :: "...". op(1200, fx, #), op(1150, fx, pred), op(1150, fx, show), op(1150, fx, abducible), dictionary/3, meta_dictionary/3, translate_goal_into_LE/2, name_as_atom/2, parsed/0, source_lang/1, dump/4, dump/3, dump/2, dump_scasp/3, split_module_name/3 ]). :- use_module('./tokenize/prolog/tokenize.pl'). :- use_module(library(pengines)). :- use_module('reasoner.pl'). :- use_module(kp_loader). :- use_module(library(prolog_stack)). :- thread_local text_size/1, error_notice/4, dict/3, meta_dict/3, example/2, local_dict/3, local_meta_dict/3, last_nl_parsed/1, kbname/1, happens/2, initiates/3, terminates/3, is_type/1, is_/2, predicates/1, events/1, fluents/1, metapredicates/1, parsed/0, source_lang/1, including/0, just_saved_scasp/2. :- discontiguous statement/3, declaration/4, _:example/2, _:query/2, _:is_/2. % Main clause: text_to_logic(+String,-Clauses) is det % Errors are added to error_notice % text_to_logic/2 text_to_logic(String_, Translation) :- % hack to ensure a newline at the end, for the sake of error reporting: ((sub_atom(String_,_,1,0,NL), memberchk(NL,['\n','\r']) ) -> String=String_ ; atom_concat(String_,'\n',String)), tokenize(String, Tokens, [cased(true), spaces(true), numbers(false)]), retractall(last_nl_parsed(_)), asserta(last_nl_parsed(1)), % preparing line counting unpack_tokens(Tokens, UTokens), clean_comments(UTokens, CTokens), !, %print_message(informational, "Tokens: ~w"-[CTokens]), phrase(document(Translation), CTokens). %( phrase(document(Translation), CTokens) -> % ( print_message(informational, "Translation: ~w"-[Translation]) ) %; ( print_message(informational, "Translation failed: ~w"-[CTokens]), Translation=[], fail)). % document/3 (or document/1 in dcg) document(Translation, In, Rest) :- (parsed -> retractall(parsed); true), (including -> retract(including); true), (source_lang(_L) -> retractall(source_lang(_)) ; true), phrase(header(Settings), In, AfterHeader), !, %print_message(informational, "Declarations completed: ~w"-[Settings]), phrase(content(Content), AfterHeader, Rest), append(Settings, Content, Original), !, append(Original, [if(is_(A,B), (nonvar(B), is(A,B)))], Translation), % adding def of is_2 last! assertz(parsed). % header parses all the declarations and assert them into memory to be invoked by the rules. % header/3 header(Settings, In, Next) :- length(In, TextSize), % after comments were removed phrase(settings(DictEntries, Settings_), In, Next), fix_settings(Settings_, Settings2), RulesforErrors = [(text_size(TextSize))|Settings2], % is text_size being used? % asserting the Settings too! predicates, events and fluents included_files(Settings2, RestoredDictEntries, CollectedRules), append(Settings2, CollectedRules, Settings), % sending rules for term expansion append(DictEntries, RestoredDictEntries, AllDictEntries), order_templates(AllDictEntries, OrderedEntries), process_types_dict(OrderedEntries, Types), %print_message(informational, "types ~w rules ~w"-[Types, CollectedRules]), append(OrderedEntries, RulesforErrors, SomeRules), append(SomeRules, Types, MRules), assertall(MRules), !. % asserting contextual information header(_, Rest, _) :- asserterror('LE error in the header ', Rest), fail. fix_settings(Settings_, Settings2) :- ( member(target(_), Settings_) -> Settings1 = Settings_ ; Settings1 = [target(taxlog)|Settings_] ), !, % taxlog as default Settings2 = [query(null, true), example(null, []), abducible(true,true)|Settings1]. % a hack to stop the loop when query is empty included_files(Settings2, RestoredDictEntries, CollectedRules) :- member(in_files(ModuleNames), Settings2), % include all those files and get additional DictEntries before ordering print_message(informational, "Module Names ~w\n"-[ModuleNames]), assertz(including), !, % cut to prevent escaping failure of load_all_files load_all_files(ModuleNames, RestoredDictEntries, CollectedRules), print_message(informational, "Restored Entries ~w\n"-[RestoredDictEntries]). included_files(_, [], []). %load_all_files/2 %load the prolog files that correspond to the modules names listed in the section of inclusion %and produces the list of entries that must be added to the dictionaries load_all_files([], [], []). load_all_files([Name|R], AllDictEntries, AllRules) :- print_message(informational, "Loading ~w"-[Name]), split_module_name(Name, File, URL), print_message(informational, "File ~w URL ~w"-[File, URL]), concat(File, "-prolog", Part1), concat(Part1, ".pl", Filename), (URL\=''->atomic_list_concat([File,'-prolog', '+', URL], NewName); atomic_list_concat([File,'-prolog'], NewName)), print_message(informational, "File ~w FullName ~w"-[Filename, NewName]), load_named_file(Filename, NewName, true), !, print_message(informational, "the dictionaries of ~w being restored into module ~w"-[NewName]), (NewName:local_dict(_,_,_) -> findall(dict(A,B,C), NewName:local_dict(A,B,C), ListDict) ; ListDict = []), (NewName:local_meta_dict(_,_,_) -> findall(meta_dict(A,B,C), NewName:local_meta_dict(A,B,C), ListMetaDict); ListMetaDict = []), append(ListDict, ListMetaDict, DictEntries), %print_message(informational, "the dictionaries being restored are ~w"-[DictEntries]), %listing(NewName:_), findall(if(H,B), (member(dict(E, _,_), DictEntries), E\=[], H=..E, clause(NewName:H, B)), Rules), findall(Pred, (member(dict(E,_,_), ListDict), E\=[], Pred=..E), ListOfPred), findall(MPred, (member(dict(ME,_,_), ListMetaDict), ME\=[], MPred=..ME), ListOfMPred), append([predicates(ListOfPred), metapredicates(ListOfMPred)], Rules, TheseRules), % for term expansion %print_message(informational, "rules to copy ~w"-[Rules]), %collect_all_preds(SwishModule, DictEntries, Preds), %print_message(informational, "the dictionaries being set dynamics are ~w"-[Preds]), %declare_preds_as_dynamic(SwishModule, Preds) %print_message(informational, "Loaded ~w"-[Filename]), load_all_files(R, RDict, NextRules), append(RDict, DictEntries, AllDictEntries), append(TheseRules, NextRules, AllRules). load_all_files([Filename|_], [], []) :- print_message(informational, "Failed to load file ~w"-[Filename]), fail. % Experimental rules for processing types: process_types_dict(Dictionary, Type_entries) :- findall(Word, ( (member(dict([_|GoalElements], Types, _), Dictionary); member(meta_dict([_|GoalElements], Types, _), Dictionary)), member((_Name-Type), Types), process_types_or_names([Type], GoalElements, Types, TypeWords), concat_atom(TypeWords, '_', Word), Word\=''), Templates), (Templates\=[] -> setof(is_type(Ty), member(Ty, Templates), Type_entries) ; Type_entries = []). % Experimental rules for reordering of templates % order_templates/2 order_templates(NonOrdered, Ordered) :- predsort(compare_templates, NonOrdered, Ordered). compare_templates(<, meta_dict(_,_,_), dict(_,_,_)). compare_templates(=, dict(_,_,T1), dict(_,_,T2)) :- T1 =@= T2. compare_templates(<, dict(_,_,T1), dict(_,_,T2)) :- length(T1, N1), length(T2, N2), N1>N2. compare_templates(<, dict(_,_,T1), dict(_,_,T2)) :- length(T1, N), length(T2, N), template_before(T1, T2). compare_templates(>, Dict1, Dict2) :- not(compare_templates(=, Dict1, Dict2)), not(compare_templates(<, Dict1, Dict2)). compare_templates(=, meta_dict(_,_,T1), meta_dict(_,_,T2)) :- T1 =@= T2. compare_templates(<, meta_dict(_,_,T1), meta_dict(_,_,T2)) :- length(T1, N1), length(T2, N2), N1>N2. compare_templates(<, meta_dict(_,_,T1), meta_dict(_,_,T2)) :- length(T1, N), length(T2, N), template_before(T1, T2). template_before([H1], [H2]) :- H1 =@= H2. template_before([H1|_R1], [H2|_R2]) :- nonvar(H1), var(H2). template_before([H1|_R1], [H2|_R2]) :- H1 @> H2. template_before([H1|R1], [H2|R2]) :- H1=@=H2, template_before(R1, R2). /* --------------------------------------------------------- LE DCGs */ % settings/2 or /4 settings(AllR, AllS) --> spaces_or_newlines(_), declaration(Rules,Setting), settings(RRules, RS), {append(Setting, RS, AllS), append(Rules, RRules, AllR)}, !. settings([], [], Stay, Stay) :- !, ( phrase(rules_previous(_), Stay, _) ; phrase(scenario_, Stay, _) ; phrase(query_, Stay, _) ). % settings ending with the start of the knowledge base or scenarios or queries. settings(_, _, Rest, _) :- asserterror('LE error in the declarations on or before ', Rest), fail. settings([], [], Stay, Stay). % content structure: cuts added to avoid search loop % content/1 or /3 content(T) --> %{print_message(informational, "going for KB:"-[])}, spaces_or_newlines(_), rules_previous(Kbname), %{print_message(informational, "KBName: ~w"-[Kbname])}, kbase_content(S), %{print_message(informational, "KB: ~w"-[S])}, content(R), {append([kbname(Kbname)|S], R, T)}, !. content(T) --> %{print_message(informational, "going for scenario:"-[])}, spaces_or_newlines(_), scenario_content(S), !, %{print_message(informational, "scenario: ~w"-[S])}, content(R), {append(S, R, T)}, !. content(T) --> %{print_message(informational, "going for query:"-[])}, spaces_or_newlines(_), query_content(S), !, content(R), {append(S, R, T)}, !. content([]) --> spaces_or_newlines(_), []. content(_, Rest, _) :- asserterror('LE error in the content ', Rest), fail. % kbase_content/1 or /3 kbase_content(T) --> spaces_or_newlines(_), statement(S), kbase_content(R), {append(S, R, T)}, !. kbase_content([]) --> spaces_or_newlines(_), []. kbase_content(_, Rest, _) :- asserterror('LE error in a knowledge base ', Rest), fail. % declaration/2 or /4 % target declaration([], [target(Language)]) --> % one word description for the language: prolog, taxlog spaces(_), [the], spaces(_), [target], spaces(_), [language], spaces(_), [is], spaces(_), colon_or_not_, spaces(_), [Language], spaces(_), period, !, {assertz(source_lang(en))}. % french: la langue cible est : prolog declaration([], [target(Language)]) --> % one word description for the language: prolog, taxlog spaces(_), [la], spaces(_), [langue], spaces(_), [cible], spaces(_), [est], spaces(_), colon_or_not_, spaces(_), [Language], spaces(_), period, !, {assertz(source_lang(fr))}. % italian: il linguaggio destinazione è : prolog declaration([], [target(Language)]) --> % one word description for the language: prolog, taxlog spaces(_), [il], spaces(_), [linguaggio], spaces(_), [destinazione], spaces(_), [è], spaces(_), colon_or_not_, spaces(_), [Language], spaces(_), period, !, {assertz(source_lang(it))}. % spanish: el lenguaje objetivo es: prolog declaration([], [target(Language)]) --> % one word description for the language: prolog, taxlog spaces(_), [el], spaces(_), [lenguaje], spaces(_), [objetivo], spaces(_), [es], spaces(_), colon_or_not_, spaces(_), [Language], spaces(_), period, !, {assertz(source_lang(es))}. % meta predicates declaration(Rules, [metapredicates(MetaTemplates)]) --> meta_predicate_previous, list_of_meta_predicates_decl(Rules, MetaTemplates), !. %timeless or just templates declaration(Rules, [predicates(Templates)]) --> predicate_previous, list_of_predicates_decl(Rules, Templates), !. %events declaration(Rules, [events(EventTypes)]) --> event_predicate_previous, list_of_predicates_decl(Rules, EventTypes), !. %time varying declaration(Rules, [fluents(Fluents)]) --> fluent_predicate_previous, list_of_predicates_decl(Rules, Fluents), !. %files to be included declaration([kbname(KBName)], [in_files(Files)]) --> files_to_include_previous(KBName), list_of_files(Files), !. % declaration(_, _, Rest, _) :- asserterror('LE error in a declaration on or before ', Rest), fail. colon_or_not_ --> [':'], spaces(_). colon_or_not_ --> []. meta_predicate_previous --> spaces(_), [the], spaces(_), [metapredicates], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_). meta_predicate_previous --> spaces(_), [the], spaces(_), [meta], spaces(_), [predicates], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_). meta_predicate_previous --> spaces(_), [the], spaces(_), [meta], spaces(_), ['-'], spaces(_), [predicates], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_). % french : les modèles sont : meta_predicate_previous --> spaces(_), [les], spaces(_), ['méta'], spaces(_), ['modèles'], spaces(_), [sont], spaces(_), [':'], spaces_or_newlines(_). % italian: i predicati sono: meta_predicate_previous --> spaces(_), [i], spaces(_), [meta], spaces(_), [modelli], spaces(_), [sono], spaces(_), [':'], spaces_or_newlines(_). % spanish: los predicados son: meta_predicate_previous --> spaces(_), [los], spaces(_), [meta], spaces(_), [predicados], spaces(_), [son], spaces(_), [':'], spaces_or_newlines(_). predicate_previous --> spaces(_), [the], spaces(_), [predicates], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_). predicate_previous --> spaces(_), [the], spaces(_), [templates], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_). predicate_previous --> spaces(_), [the], spaces(_), [timeless], spaces(_), [predicates], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_). % french : les modèles sont : predicate_previous --> spaces(_), [les], spaces(_), ['modèles'], spaces(_), [sont], spaces(_), [':'], spaces_or_newlines(_). % italian: i predicati sono: predicate_previous --> spaces(_), [i], spaces(_), [modelli], spaces(_), [sono], spaces(_), [':'], spaces_or_newlines(_). % spanish: los predicados son: predicate_previous --> spaces(_), [los], spaces(_), [predicados], spaces(_), [son], spaces(_), [':'], spaces_or_newlines(_). event_predicate_previous --> spaces(_), [the], spaces(_), [event], spaces(_), [predicates], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_). fluent_predicate_previous --> spaces(_), [the], spaces(_), [fluents], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_). fluent_predicate_previous --> spaces(_), [the], spaces(_), [time], ['-'], [varying], spaces(_), [predicates], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_). files_to_include_previous(KBName) --> spaces_or_newlines(_), [the], spaces(_), ['knowledge'], spaces(_), [base], extract_constant([includes], NameWords), [includes], spaces(_), [these], spaces(_), [files], spaces(_), [':'], !, spaces_or_newlines(_), {name_as_atom(NameWords, KBName)}. % at least one predicate declaration required list_of_predicates_decl([], []) --> spaces_or_newlines(_), next_section, !. list_of_predicates_decl([Ru|Rin], [F|Rout]) --> spaces_or_newlines(_), predicate_decl(Ru,F), comma_or_period, list_of_predicates_decl(Rin, Rout), !. list_of_predicates_decl(_, _, Rest, _) :- asserterror('LE error found in a template declaration ', Rest), fail. % at least one predicate declaration required list_of_meta_predicates_decl([], []) --> spaces_or_newlines(_), next_section, !. list_of_meta_predicates_decl([Ru|Rin], [F|Rout]) --> spaces_or_newlines(_), meta_predicate_decl(Ru,F), comma_or_period, list_of_meta_predicates_decl(Rin, Rout). list_of_meta_predicates_decl(_, _, Rest, _) :- asserterror('LE error found in the declaration of a meta template ', Rest), fail. list_of_files([]) --> spaces_or_newlines(_), next_section, !. list_of_files([Filename|Rout]) --> spaces_or_newlines(_), extract_string([Filename]), list_of_files(Rout), !. %{name_as_atom(NameWords, Filename)}. list_of_files(_, Rest, _) :- asserterror('LE error found in a file to include ', Rest), fail. % next_section/2 % a hack to avoid superflous searches format(string(Mess), "~w", [StopHere]), print_message(informational, Message), next_section(StopHere, StopHere) :- phrase(meta_predicate_previous, StopHere, _), !. % format(string(Message), "Next meta predicates", []), print_message(informational, Message). next_section(StopHere, StopHere) :- phrase(predicate_previous, StopHere, _), !. % format(string(Message), "Next predicates", []), print_message(informational, Message). next_section(StopHere, StopHere) :- phrase(event_predicate_previous, StopHere, _), !. % format(string(Message), "Next ecent predicates", []), print_message(informational, Message). next_section(StopHere, StopHere) :- phrase(fluent_predicate_previous, StopHere, _), !. % format(string(Message), "Next fluents", []), print_message(informational, Message). next_section(StopHere, StopHere) :- phrase(files_to_include_previous(_), StopHere, _), !. next_section(StopHere, StopHere) :- phrase(rules_previous(_), StopHere, _), !. % format(string(Message), "Next knowledge base", []), print_message(informational, Message). next_section(StopHere, StopHere) :- phrase(scenario_, StopHere, _), !. % format(string(Message), "Next scenario", []), print_message(informational, Message). next_section(StopHere, StopHere) :- phrase(query_, StopHere, _). % format(string(Message), "Next query", []), print_message(informational, Message). % predicate_decl/2 predicate_decl(dict([Predicate|Arguments],TypesAndNames, Template), Relation) --> spaces(_), template_decl(RawTemplate), {build_template(RawTemplate, Predicate, Arguments, TypesAndNames, Template), Relation =.. [Predicate|Arguments]}, !. % we are using this resource of the last clause to record the error and its details % not very useful with loops, of course. % error clause predicate_decl(_, _, Rest, _) :- asserterror('LE error found in a declaration ', Rest), fail. % meta_predicate_decl/2 meta_predicate_decl(meta_dict([Predicate|Arguments],TypesAndNames, Template), Relation) --> spaces(_), template_decl(RawTemplate), {build_template(RawTemplate, Predicate, Arguments, TypesAndNames, Template), Relation =.. [Predicate|Arguments]}. meta_predicate_decl(_, _, Rest, _) :- asserterror('LE error found in a meta template declaration ', Rest), fail. rules_previous(default) --> spaces_or_newlines(_), [the], spaces(_), [rules], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_), !. rules_previous(KBName) --> spaces_or_newlines(_), [the], spaces(_), ['knowledge'], spaces(_), [base], extract_constant([includes], NameWords), [includes], spaces(_), [':'], !, spaces_or_newlines(_), {name_as_atom(NameWords, KBName)}. rules_previous(default) --> % backward compatibility spaces_or_newlines(_), [the], spaces(_), ['knowledge'], spaces(_), [base], spaces(_), [includes], spaces(_), [':'], spaces_or_newlines(_). % italian: la base di conoscenza include rules_previous(KBName) --> spaces_or_newlines(_), [la], spaces(_), [base], spaces(_), [di], spaces(_), [conoscenza], spaces(_), extract_constant([include], NameWords), [include], spaces(_), [':'], !, spaces_or_newlines(_), {name_as_atom(NameWords, KBName)}. % french: la base de connaissances dont le nom est comprend : rules_previous(KBName) --> spaces_or_newlines(_), [la], spaces(_), [base], spaces(_), [de], spaces(_), [connaissances], spaces(_), [dont], spaces(_), [le], spaces(_), [nom], spaces(_), [est], extract_constant([comprend], NameWords), [comprend], spaces(_), [':'], !, spaces_or_newlines(_), {name_as_atom(NameWords, KBName)}. % spanish: la base de conocimiento incluye: rules_previous(KBName) --> spaces_or_newlines(_), [la], spaces(_), [base], spaces(_), [de], spaces(_), [conocimiento], extract_constant([incluye], NameWords), [incluye], spaces(_), [':'], !, spaces_or_newlines(_), {name_as_atom(NameWords, KBName)}. % scenario_content/1 or /3 % a scenario description: assuming one example -> one scenario -> one list of facts. scenario_content(Scenario) --> scenario_, extract_constant([is, es, est, è], NameWords), is_colon_, newline, %list_of_facts(Facts), period, !, spaces(_), assumptions_(Assumptions), !, % period is gone {name_as_atom(NameWords, Name), Scenario = [example( Name, [scenario(Assumptions, true)])]}. scenario_content(_, Rest, _) :- asserterror('LE error found around this scenario expression: ', Rest), fail. % query_content/1 or /3 % statement: the different types of statements in a LE text % a query query_content(Query) --> query_, extract_constant([is, es, est, è], NameWords), is_colon_, spaces_or_newlines(_), query_header(Ind0, Map1), conditions(Ind0, Map1, _, Conds), !, period, % period stays! {name_as_atom(NameWords, Name), Query = [query(Name, Conds)]}. query_content(_, Rest, _) :- asserterror('LE error found around this expression: ', Rest), fail. % (holds_at(_149428,_149434) if % (happens_at(_150138,_150144), % initiates_at(_150138,_149428,_150144)), % _150144 before _149434, % not ((terminates_at(_152720,_149428,_152732),_150144 before _152732),_152732 before _149434)) % it becomes the case that % fluent % when % event % if % statement/1 or /3 statement(Statement) --> it_becomes_the_case_that_, spaces_or_newlines(_), literal_([], Map1, holds(Fluent, _)), spaces_or_newlines(_), when_, spaces_or_newlines(_), literal_(Map1, Map2, happens(Event, T)), spaces_or_newlines(_), body_(Body, [map(T, '_change_time')|Map2],_), period, {(Body = [] -> Statement = [if(initiates(Event, Fluent, T), true)]; (Statement = [if(initiates(Event, Fluent, T), Body)]))}, !. % it becomes not the case that % fluent % when % event % if statement(Statement) --> it_becomes_not_the_case_that_, spaces_or_newlines(_), literal_([], Map1, holds(Fluent, _)), spaces_or_newlines(_), when_, spaces_or_newlines(_), literal_(Map1, Map2, happens(Event, T)), spaces_or_newlines(_), body_(Body, [map(T, '_change_time')|Map2],_), period, {(Body = [] -> Statement = [if(terminates(Event, Fluent, T), true)]; (Statement = [if(terminates(Event, Fluent, T), Body)] %, print_message(informational, "~w"-Statement) ))}, !. % it is illegal that % event % if ... statement(Statement) --> it_is_illegal_that_, spaces_or_newlines(_), literal_([], Map1, happens(Event, T)), body_(Body, Map1, _), period, {(Body = [] -> Statement = [if(it_is_illegal(Event, T), true)]; Statement = [if(it_is_illegal(Event, T), Body)])},!. % it is unknown whether statement(Statement) --> it_is_unknown_whether_, spaces_or_newlines(_), literal_([], Map1, Abducible), body_(Body, Map1, _), period, {(Body = [] -> Statement = [abducible(Abducible, true)]; Statement = [abducible(Abducible, Body)])},!. % a fact or a rule statement(Statement) --> currentLine(L), literal_([], Map1, Head), body_(Body, Map1, _), period, {(Body = [] -> Statement = [if(L, Head, true)]; Statement = [if(L, Head, Body)])}. % error statement(_, Rest, _) :- asserterror('LE error found around this statement: ', Rest), fail. list_of_facts([F|R1]) --> literal_([], _,F), rest_list_of_facts(R1). rest_list_of_facts(L1) --> comma, spaces_or_newlines(_), list_of_facts(L1). rest_list_of_facts([]) --> []. % assumptions_/3 or /5 assumptions_([A|R]) --> spaces_or_newlines(_), rule_([], _, A), !, assumptions_(R). assumptions_([]) --> spaces_or_newlines(_), []. rule_(InMap, InMap, Rule) --> it_is_unknown_whether_, spaces_or_newlines(_), literal_([], Map1, Abducible), body_(Body, Map1, _), period, {(Body = [] -> Rule = (abducible(Abducible, true):-true); Rule = (abducible(Abducible, Body):-true))},!. rule_(InMap, OutMap, Rule) --> literal_(InMap, Map1, Head), body_(Body, Map1, OutMap), period, %spaces(Ind), condition(Head, Ind, InMap, Map1), body_(Body, Map1, OutMap), period, {(Body = [] -> Rule = (Head :-true); Rule = (Head :- Body))}. rule_(M, M, _, Rest, _) :- asserterror('LE error found in an assumption, near to ', Rest), fail. % no prolog inside LE! %statement([Fact]) --> % spaces(_), prolog_literal_(Fact, [], _), spaces_or_newlines(_), period. % body/3 or /5 body_([], Map, Map) --> spaces_or_newlines(_). body_(Conditions, Map1, MapN) --> newline, spaces(Ind), if_, !, conditions(Ind, Map1, MapN, Conditions), spaces_or_newlines(_). body_(Conditions, Map1, MapN) --> if_, newline_or_nothing, spaces(Ind), conditions(Ind, Map1, MapN, Conditions), spaces_or_newlines(_). newline_or_nothing --> newline. newline_or_nothing --> []. % literal_/3 or /5 % literal_ reads a list of words until it finds one of these: ['\n', if, '.'] % it then tries to match those words against a template in memory (see dict/3 predicate). % The output is then contigent to the type of literal according to the declarations. literal_(Map1, MapN, FinalLiteral) --> % { print_message(informational, 'at time, literal') }, at_time(T, Map1, Map2), comma, possible_instance(PossibleTemplate), {match_template(PossibleTemplate, Map2, MapN, Literal), (fluents(Fluents) -> true; Fluents = []), (events(Events) -> true; Events = []), (lists:member(Literal, Events) -> FinalLiteral = happens(Literal, T) ; (lists:member(Literal, Fluents) -> FinalLiteral = holds(Literal, T) ; FinalLiteral = Literal))}, !. % by default (including builtins) they are timeless! literal_(Map1, MapN, FinalLiteral) --> % { print_message(informational, 'literal, at time') }, possible_instance(PossibleTemplate), comma, at_time(T, Map1, Map2), {match_template(PossibleTemplate, Map2, MapN, Literal), (fluents(Fluents) -> true; Fluents = []), (events(Events) -> true; Events = []), (lists:member(Literal, Events) -> FinalLiteral = happens(Literal, T) ; (lists:member(Literal, Fluents) -> FinalLiteral = holds(Literal, T) ; FinalLiteral = Literal))}, !. % by default (including builtins) they are timeless! literal_(Map1, MapN, FinalLiteral) --> possible_instance(PossibleTemplate), %{ print_message(informational, "~w"-[PossibleTemplate]) }, {match_template(PossibleTemplate, Map1, MapN, Literal), (fluents(Fluents) -> true; Fluents = []), (events(Events) -> true; Events = []), (consult_map(Time, '_change_time', Map1, _MapF) -> T=Time; true), (lists:member(Literal, Events) -> FinalLiteral = happens(Literal, T) ; (lists:member(Literal, Fluents) -> FinalLiteral = holds(Literal, T) ; (FinalLiteral = Literal))) %print_message(informational, "~w with ~w"-[FinalLiteral, MapF]) }, !. % by default (including builtins) they are timeless! % rewritten to use in swish. Fixed! It was a name clash. Apparently "literal" is used somewhere else %literal_(Map1, MapN, Literal, In, Out) :- print_message(informational, ' inside a literal'), % possible_instance(PossibleTemplate, In, Out), print_message(informational, PossibleTemplate), % match_template(PossibleTemplate, Map1, MapN, Literal). % error clause literal_(M, M, _, Rest, _) :- asserterror('LE error found in a literal ', Rest), fail. % conditions/4 or /6 conditions(Ind0, Map1, MapN, Conds) --> list_of_conds_with_ind(Ind0, Map1, MapN, Errors, ListConds), {Errors=[] -> ri(Conds, ListConds); (assert_error_os(Errors), fail)}. % preempty validation of errors conditions(_, Map, Map, _, Rest, _) :- asserterror('LE indentation error ', Rest), fail. % list_of_conds_with_ind/5 % list_of_conds_with_ind(+InitialInd, +InMap, -OutMap, -Errors, -ListOfConds) list_of_conds_with_ind(Ind0, Map1, MapN, [], [Cond|Conditions]) --> condition(Cond, Ind0, Map1, Map2), more_conds(Ind0, Ind0,_, Map2, MapN, Conditions). list_of_conds_with_ind(_, M, M, [error('Error in condition at', LineNumber, Tokens)], [], Rest, _) :- once( nth1(N,Rest,newline(NextLine)) ), LineNumber is NextLine-2, RelevantN is N-1, length(Relevant,RelevantN), append(Relevant,_,Rest), findall(Token, (member(T,Relevant), (T=newline(_) -> Token='\n' ; Token=T)), Tokens). more_conds(Ind0, _, Ind3, Map1, MapN, [ind(Ind2), Op, Cond2|RestMapped]) --> newline, spaces(Ind2), {Ind0 =< Ind2}, % if the new indentation is deeper, it goes on as before. operator(Op), condition(Cond2, Ind2, Map1, Map2), %{print_message(informational, "~w"-[Conditions])}, !, more_conds(Ind0, Ind2, Ind3, Map2, MapN, RestMapped). more_conds(_, Ind, Ind, Map, Map, [], L, L). % this naive definition of term is problematic % term_/4 or /6 term_(StopWords, Term, Map1, MapN) --> (variable(StopWords, Term, Map1, MapN), !); (constant(StopWords, Term, Map1, MapN), !); (list_(Term, Map1, MapN), !). %; (compound_(Term, Map1, MapN), !). % list_/3 or /5 list_(List, Map1, MapN) --> spaces(_), bracket_open_, !, extract_list([']'], List, Map1, MapN), bracket_close. compound_(V1/V2, Map1, MapN) --> term_(['/'], V1, Map1, Map2), ['/'], term_([], V2, Map2, MapN). % event observations %condition(happens(Event), _, Map1, MapN) --> % observe_, literal_(Map1, MapN, Event), !. % condition/4 or /6 % this produces a Taxlog condition with the form: % setof(Owner/Share, is_ultimately_owned_by(Asset,Owner,Share) on Before, SetOfPreviousOwners) % from a set of word such as: % and a record of previous owners is a set of [an owner, a share] % where the asset is ultimately owned by the share with the owner at the previous time condition(FinalExpression, _, Map1, MapN) --> variable([is], Set, Map1, Map2), is_a_set_of_, term_([], Term, Map2, Map3), !, % moved where to the following line newline, spaces(Ind2), where_, conditions(Ind2, Map3, Map4, Goals), modifiers(setof(Term,Goals,Set), Map4, MapN, FinalExpression). % for every a party is a party in the event, it is the case that: condition(FinalExpression, _, Map1, MapN) --> for_all_cases_in_which_, newline, !, spaces(Ind2), conditions(Ind2, Map1, Map2, Conds), spaces_or_newlines(_), it_is_the_case_that_, newline, spaces(Ind3), conditions(Ind3, Map2, Map3, Goals), modifiers(forall(Conds,Goals), Map3, MapN, FinalExpression). % the Value is the sum of each Asset Net such that condition(FinalExpression, _, Map1, MapN) --> variable([is], Value, Map1, Map2), is_the_sum_of_each_, extract_variable([such], [], NameWords, [], _), such_that_, !, { name_predicate(NameWords, Name), update_map(Each, Name, Map2, Map3) }, newline, spaces(Ind), conditions(Ind, Map3, Map4, Conds), modifiers(aggregate_all(sum(Each),Conds,Value), Map4, MapN, FinalExpression). % it is not the case that %condition((pengine_self(M), not(M:Conds)), _, Map1, MapN) --> %condition((true, not(Conds)), _, Map1, MapN) --> condition(not(Conds), _, Map1, MapN) --> %condition(not(Conds), _, Map1, MapN) --> spaces(_), not_, newline, % forget other choices. We know it is a not case spaces(Ind), conditions(Ind, Map1, MapN, Conds), !. condition(Cond, _, Map1, MapN) --> literal_(Map1, MapN, Cond), !. %condition(assert(Prolog), _, Map1, MapN) --> % this_information_, !, prolog_literal_(Prolog, Map1, MapN), has_been_recorded_. % condition(-Cond, ?Ind, +InMap, -OutMap) % builtins have been included as predefined templates in the predef_dict %condition(InfixBuiltIn, _, Map1, MapN) --> % term_(Term, Map1, Map2), spaces_or_newlines(_), builtin_(BuiltIn), % spaces_or_newlines(_), expression_(Expression, Map2, MapN), !, {InfixBuiltIn =.. [BuiltIn, Term, Expression]}. % error clause condition(_, _Ind, Map, Map, Rest, _) :- asserterror('LE error found at a condition ', Rest), fail. % modifiers add reifying predicates to an expression. % modifiers(+MainExpression, +MapIn, -MapOut, -FinalExpression) modifiers(MainExpression, Map1, MapN, on(MainExpression, Var) ) --> newline, spaces(_), at_, variable([], Var, Map1, MapN). % newline before a reifying expression modifiers(MainExpression, Map, Map, MainExpression) --> []. % variable/4 or /6 variable(StopWords, Var, Map1, MapN) --> spaces(_), indef_determiner, extract_variable(StopWords, [], NameWords, [], _), % <-- CUT! { NameWords\=[], name_predicate(NameWords, Name), update_map(Var, Name, Map1, MapN) }. variable(StopWords, Var, Map1, MapN) --> spaces(_), def_determiner, extract_variable(StopWords, [], NameWords, [], _), % <-- CUT! { NameWords\=[], name_predicate(NameWords, Name), consult_map(Var, Name, Map1, MapN) }. % allowing for symbolic variables: variable(StopWords, Var, Map1, MapN) --> spaces(_), extract_variable(StopWords, [], NameWords, [], _), { NameWords\=[], name_predicate(NameWords, Name), consult_map(Var, Name, Map1, MapN) }. % constant/4 or /6 constant(StopWords, Constant, Map, Map) --> extract_constant(StopWords, NameWords), { NameWords\=[], name_predicate(NameWords, Constant) }. % deprecated prolog_literal_(Prolog, Map1, MapN) --> predicate_name_(Predicate), parentesis_open_, extract_list([], Arguments, Map1, MapN), parentesis_close_, {Prolog =.. [Predicate|Arguments]}. predicate_name_(Module:Predicate) --> [Module], colon_, extract_constant([], NameWords), { name_predicate(NameWords, Predicate) }, !. predicate_name_(Predicate) --> extract_constant([], NameWords), { name_predicate(NameWords, Predicate) }. at_time(T, Map1, MapN) --> spaces_or_newlines(_), at_, expression_(T, Map1, MapN), spaces_or_newlines(_). spaces(N) --> [' '], !, spaces(M), {N is M + 1}. % todo: reach out for codemirror's configuration https://codemirror.net/doc/manual.html for tabSize spaces(N) --> ['\t'], !, spaces(M), {N is M + 4}. % counting tab as four spaces (default in codemirror) spaces(0) --> []. spaces_or_newlines(N) --> [' '], !, spaces_or_newlines(M), {N is M + 1}. spaces_or_newlines(N) --> ['\t'], !, spaces_or_newlines(M), {N is M + 4}. % counting tab as four spaces. See above spaces_or_newlines(N) --> newline, !, spaces_or_newlines(M), {N is M + 1}. % counting \r as one space spaces_or_newlines(0) --> []. newline --> [newline(_Next)]. one_or_many_newlines --> newline, spaces(_), one_or_many_newlines, !. one_or_many_newlines --> []. if_ --> [if], spaces_or_newlines(_). % so that if can be written many lines away from the rest if_ --> [se], spaces_or_newlines(_). % italian if_ --> [si], spaces_or_newlines(_). % french and spanish period --> ['.']. comma --> [',']. colon_ --> [':'], spaces(_). comma_or_period --> period, !. comma_or_period --> comma. and_ --> [and]. and_ --> [e]. % italian and_ --> [et]. % french and_ --> [y]. % spanish or_ --> [or]. or_ --> [o]. % italian and spanish or_ --> [ou]. % french not_ --> [it], spaces(_), [is], spaces(_), [not], spaces(_), [the], spaces(_), [case], spaces(_), [that], spaces(_). not_ --> [non], spaces(_), [risulta], spaces(_), [che], spaces(_). % italian not_ --> [ce], spaces(_), [n],[A],[est], spaces(_), [pas], spaces(_), [le], spaces(_), [cas], spaces(_), [que], spaces(_), {atom_string(A, "'")}. % french not_ --> [no], spaces(_), [es], spaces(_), [el], spaces(_), [caso], spaces(_), [que], spaces(_). % spanish is_the_sum_of_each_ --> [is], spaces(_), [the], spaces(_), [sum], spaces(_), [of], spaces(_), [each], spaces(_) . is_the_sum_of_each_ --> [è], spaces(_), [la], spaces(_), [somma], spaces(_), [di], spaces(_), [ogni], spaces(_). % italian is_the_sum_of_each_ --> [es], spaces(_), [la], spaces(_), [suma], spaces(_), [de], spaces(_), [cada], spaces(_). % spanish is_the_sum_of_each_ --> [est], spaces(_), [la], spaces(_), [somme], spaces(_), [de], spaces(_), [chaque], spaces(_). % french such_that_ --> [such], spaces(_), [that], spaces(_). such_that_ --> [tale], spaces(_), [che], spaces(_). % italian such_that_ --> [tel], spaces(_), [que], spaces(_). % french such_that_ --> [tal], spaces(_), [que], spaces(_). % spanish at_ --> [at], spaces(_). at_ --> [a], spaces(_). % italian minus_ --> ['-'], spaces(_). plus_ --> ['+'], spaces(_). divide_ --> ['/'], spaces(_). times_ --> ['*'], spaces(_). bracket_open_ --> [A], spaces(_), {atom_string(A, "[")}. bracket_close --> [A], spaces(_), {atom_string(A, "]")}. parentesis_open_ --> ['('], spaces(_). parentesis_close_ --> [A], spaces(_), {atom_string(A, ")")}. this_information_ --> [this], spaces(_), [information], spaces(_). has_been_recorded_ --> [has], spaces(_), [been], spaces(_), [recorded], spaces(_). for_all_cases_in_which_ --> spaces_or_newlines(_), [for], spaces(_), [all], spaces(_), [cases], spaces(_), [in], spaces(_), [which], spaces(_). for_all_cases_in_which_ --> spaces_or_newlines(_), [pour], spaces(_), [tous], spaces(_), [les], spaces(_), [cas], spaces(_), [o],[ù], spaces(_). % french for_all_cases_in_which_ --> spaces_or_newlines(_), [per], spaces(_), [tutti], spaces(_), [i], spaces(_), [casi], spaces(_), [in], spaces(_), [cui], spaces(_). % italian for_all_cases_in_which_ --> spaces_or_newlines(_), [en], spaces(_), [todos], spaces(_), [los], spaces(_), [casos], spaces(_), [en], spaces(_), [los], spaces(_), [que], spaces(_). % spanish for_all_cases_in_which_ --> spaces_or_newlines(_), [en], spaces(_), [cualquier], spaces(_), [caso], spaces(_), [en], spaces(_), [el], spaces(_), [que], spaces(_). % spanish it_is_the_case_that_ --> [it], spaces(_), [is], spaces(_), [the], spaces(_), [case], spaces(_), [that], spaces(_). it_is_the_case_that_ --> [es], spaces(_), [el], spaces(_), [caso], spaces(_), [que], spaces(_). % spanish it_is_the_case_that_ --> [es], spaces(_), [también], spaces(_), [el], spaces(_), [caso], spaces(_), [que], spaces(_). % spanish it_is_the_case_that_ --> [c], [A], [est], spaces(_), [le], spaces(_), [cas], spaces(_), [que], spaces(_), {atom_string(A, "'")}. % french it_is_the_case_that_ --> [è], spaces(_), [provato], spaces(_), [che], spaces(_). % italian is_a_set_of_ --> [is], spaces(_), [a], spaces(_), [set], spaces(_), [of], spaces(_). is_a_set_of_ --> [es], spaces(_), [un], spaces(_), [conjunto], spaces(_), [de], spaces(_). % spanish is_a_set_of_ --> [est], spaces(_), [un], spaces(_), [ensemble], spaces(_), [de], spaces(_). % french is_a_set_of_ --> [est], spaces(_), [un], spaces(_), [ensemble], spaces(_), [de], spaces(_). % italian where_ --> [where], spaces(_). where_ --> [en], spaces(_), [donde], spaces(_). % spanish where_ --> ['où'], spaces(_). % french where_ --> [dove], spaces(_). % italian where_ --> [quando], spaces(_). % italian where_ --> [donde], spaces(_). % spanish scenario_ --> spaces_or_newlines(_), ['Scenario'], !, spaces(_). scenario_ --> spaces_or_newlines(_), [scenario], spaces(_). % english and italian scenario_ --> spaces_or_newlines(_), [le], spaces(_), [scénario], spaces(_). % french scenario_ --> spaces_or_newlines(_), [escenario], spaces(_). % spanish is_colon_ --> [is], spaces(_), [':'], spaces(_). is_colon_ --> [es], spaces(_), [':'], spaces(_). % spanish is_colon_ --> [est], spaces(_), [':'], spaces(_). % french is_colon_ --> [è], spaces(_), [':'], spaces(_). % italian query_ --> spaces_or_newlines(_), ['Query'], !, spaces(_). query_ --> spaces_or_newlines(_), [query], spaces(_). query_ --> spaces_or_newlines(_), [la], spaces(_), [question], spaces(_). % french query_ --> spaces_or_newlines(_), [la], spaces(_), [pregunta], spaces(_). % spanish query_ --> spaces_or_newlines(_), [domanda], spaces(_). % italian for_which_ --> [for], spaces(_), [which], spaces(_). for_which_ --> [para], spaces(_), [el], spaces(_), [cual], spaces(_). % spanish singular for_which_ --> [pour], spaces(_), [qui], spaces(_). % french for_which_ --> [per], spaces(_), [cui], spaces(_). % italian query_header(Ind, Map) --> spaces(Ind), for_which_, list_of_vars([], Map), colon_, spaces_or_newlines(_). query_header(0, []) --> []. list_of_vars(Map1, MapN) --> extract_variable([',', and, el, et, y, ':'], [], NameWords, [], _), { name_predicate(NameWords, Name), update_map(_Var, Name, Map1, Map2) }, rest_of_list_of_vars(Map2, MapN). rest_of_list_of_vars(Map1, MapN) --> and_or_comma_, list_of_vars(Map1, MapN). rest_of_list_of_vars(Map, Map) --> []. and_or_comma_ --> [','], spaces(_). and_or_comma_ --> and_, spaces(_). it_becomes_the_case_that_ --> it_, [becomes], spaces(_), [the], spaces(_), [case], spaces(_), [that], spaces(_). it_becomes_not_the_case_that_ --> it_, [becomes], spaces(_), [not], spaces(_), [the], spaces(_), [case], spaces(_), [that], spaces(_). it_becomes_not_the_case_that_ --> it_, [becomes], spaces(_), [no], spaces(_), [longer], spaces(_), [the], spaces(_), [case], spaces(_), [that], spaces(_). when_ --> [when], spaces(_). it_ --> [it], spaces(_), !. it_ --> ['It'], spaces(_). observe_ --> [observe], spaces(_). it_is_illegal_that_ --> it_, [is], spaces(_), [illegal], spaces(_), [that], spaces(_). it_is_unknown_whether_ --> it_, [is], spaces(_), [unknown], spaces(_), [whether], spaces(_). it_is_unknown_whether_ --> it_, [is], spaces(_), [unknown], spaces(_), [that], spaces(_). it_is_unknown_whether_ --> [non], spaces(_), [è], spaces(_), [noto], spaces(_), [se], spaces(_). % italian /* --------------------------------------------------- Supporting code */ % indentation code % ri/2 ri(-Conditions, +IndentedForm). ri(P, L) :- rinden(Q, L), c2p(Q, P). % rinden/2 produces the conditions from the list with the indented form. rinden(Q, List) :- rind(_, _, Q, List). rind(L, I, Q, List) :- rind_and(L, I, Q, List); rind_or(L, I, Q, List). rind_and(100, [], true, []). rind_and(100, [], Cond, [Cond]) :- simple(Cond). rind_and(T, [T|RestT], and(First,Rest), Final) :- combine(NewF, [ind(T), and|RestC], Final), rind(T1, Tr1, First, NewF), T1>T, rind(Tn, Tr, Rest, RestC), append(Tr1, Tr, RestT), right_order_and(Rest, Tn, T). rind_or(100, [], false, []). rind_or(100, [], Cond, [Cond]) :- simple(Cond). rind_or(T, [T|RestT], or(First,Rest), Final) :- combine(NewF, [ind(T), or|RestC], Final), rind(T1, Tr1, First, NewF), T1>T, rind(Tn, Tr, Rest, RestC), append(Tr1, Tr, RestT), right_order_or(Rest, Tn, T). right_order_and(Rest, Tn, T) :- Rest=or(_,_), Tn>T. right_order_and(Rest, Tn, T) :- Rest=and(_,_), Tn=T. right_order_and(Rest, _, _) :- simple(Rest). right_order_or(Rest, Tn, T) :- Rest=and(_,_), Tn>T. right_order_or(Rest, Tn, T) :- Rest=or(_,_), Tn=T. right_order_or(Rest, _, _) :- simple(Rest). combine(F, S, O) :- ( F\=[], S=[ind(_), Op, V], ((Op==and_); (Op==or_)), simple(V), O=F) ; (F=[], O=S). combine([H|T], S, [H|NT]) :- combine(T, S, NT). simple(Cond) :- Cond\=and(_,_), Cond\=or(_,_), Cond\=true, Cond\=false. c2p(true, true). c2p(false, false). c2p(C, C) :- simple(C). c2p(and(A, RestA), (AA, RestAA)) :- c2p(A, AA), c2p(RestA, RestAA). c2p(or(A, RestA), (AA; RestAA)) :- c2p(A, AA), c2p(RestA, RestAA). /* --------------------------------------------------- More Supporting code */ clean_comments([], []) :- !. clean_comments(['%'|Rest], New) :- % like in prolog comments start with % jump_comment(Rest, Next), clean_comments(Next, New). clean_comments([Code|Rest], [Code|New]) :- clean_comments(Rest, New). jump_comment([], []). jump_comment([newline(N)|Rest], [newline(N)|Rest]). % leaving the end of line in place jump_comment([_|R1], R2) :- jump_comment(R1, R2). % template_decl/4 % cuts added to improve efficiency template_decl([], [newline(_)|RestIn], [newline(_)|RestIn]) :- asserterror('LE error: misplaced new line found in a template declaration ', RestIn), !, fail. % cntrl \n should be rejected as part of a template template_decl(RestW, [' '|RestIn], Out) :- !, % skip spaces in template template_decl(RestW, RestIn, Out). template_decl(RestW, ['\t'|RestIn], Out) :- !, % skip cntrl \t in template template_decl(RestW, RestIn, Out). % excluding ends of lines from templates %template_decl(RestW, [newline(_)|RestIn], Out) :- !, % skip cntrl \n in template % template_decl(RestW, RestIn, Out). template_decl([Word|RestW], [Word|RestIn], Out) :- not(lists:member(Word,['.', ','])), % only . and , as boundaries. Beware! template_decl(RestW, RestIn, Out), !. template_decl([], [Word|Rest], [Word|Rest]) :- lists:member(Word,['.', ',']), !. template_decl(_, Rest, _) :- asserterror('LE error found in a template declaration ', Rest), fail. % build_template/5 build_template(RawTemplate, Predicate, Arguments, TypesAndNames, Template) :- build_template_elements(RawTemplate, [], Arguments, TypesAndNames, OtherWords, Template), name_predicate(OtherWords, Predicate). % build_template_elements(+Input, +Previous, -Args, -TypesNames, -OtherWords, -Template) build_template_elements([], _, [], [], [], []) :- !. % a variable signalled by a * build_template_elements(['*', Word|RestOfWords], _Previous, [Var|RestVars], [Name-Type|RestTypes], Others, [Var|RestTemplate]) :- has_pairing_asteriks([Word|RestOfWords]), %(ind_det(Word); ind_det_C(Word)), % Previous \= [is|_], % removing this requirement when * is used phrase(determiner, [Word|RestOfWords], RRestOfWords), % allows the for variables in templates declarations only extract_variable_template(['*'], [], NameWords, [], TypeWords, RRestOfWords, ['*'|NextWords]), !, % <-- it must end with * too name_predicate(NameWords, Name), name_predicate(TypeWords, Type), build_template_elements(NextWords, [], RestVars, RestTypes, Others, RestTemplate). build_template_elements(['*', Word|RestOfWords], _Previous,_, _, _, _) :- not(has_pairing_asteriks([Word|RestOfWords])), !, fail. % produce an error report if asterisks are not paired % a variable not signalled by a * % for backward compatibility \\ DEPRECATED %build_template_elements([Word|RestOfWords], Previous, [Var|RestVars], [Name-Type|RestTypes], Others, [Var|RestTemplate]) :- % (ind_det(Word); ind_det_C(Word)), Previous \= [is|_], % extract_variable(['*'], Var, [], NameWords, TypeWords, RestOfWords, NextWords), !, % <-- CUT! % name_predicate(NameWords, Name), % name_predicate(TypeWords, Type), % build_template_elements(NextWords, [], RestVars, RestTypes, Others, RestTemplate). build_template_elements([Word|RestOfWords], Previous, RestVars, RestTypes, [Word|Others], [Word|RestTemplate]) :- build_template_elements(RestOfWords, [Word|Previous], RestVars, RestTypes, Others, RestTemplate). has_pairing_asteriks(RestOfTemplate) :- findall('*',member('*', RestOfTemplate), Asteriks), length(Asteriks, N), 1 is mod(N, 2). name_predicate(Words, Predicate) :- concat_atom(Words, '_', Predicate). % name_as_atom/2 name_as_atom([Number], Number) :- number(Number), !. name_as_atom([Atom], Number) :- atom_number(Atom, Number), !. name_as_atom(Words, Name) :- numbervars(Words, 1, _, [functor_name('unknown')]), replace_vars(Words, Atoms), list_words_to_codes(Atoms, Codes), replace_ast_a(Codes, CCodes), atom_codes(Name, CCodes). words_to_atom(Words, Name) :- %trace, numbervars(Words, 0, _, [singletons(true)]), list_words_to_codes(Words, Codes), atom_codes(Name, Codes). replace_ast_a([], []) :- !. replace_ast_a([42,32,97|Rest], [42,97|Out]) :- !, replace_final_ast(Rest, Out). replace_ast_a([C|Rest], [C|Out]) :- replace_ast_a(Rest, Out). replace_final_ast([], []) :- !. replace_final_ast([32,42|Rest], [42|Out]) :- !, replace_ast_a(Rest, Out). replace_final_ast([C|Rest], [C|Out]) :- replace_final_ast(Rest, Out). % maps a list of words to a list of corresponding codes % adding an space between words-codes (32). % list_word_to_codes/2 list_words_to_codes([], []). list_words_to_codes([Word|RestW], Out) :- atom_codes(Word, Codes), remove_quotes(Codes, CleanCodes), list_words_to_codes(RestW, Next), (Next=[]-> Out=CleanCodes; % if it comes the symbol _ + - / \ or the previous is only + o - then no space is added between words (Next=[95|_]; Next=[43|_]; Next=[45|_]; Next=[47|_]; Next=[92|_]; CleanCodes=[43]; CleanCodes=[45])-> append(CleanCodes, Next, Out); append(CleanCodes, [32|Next], Out) ), !. remove_quotes([], []) :-!. remove_quotes([39|RestI], RestC) :- remove_quotes(RestI, RestC), !. % quick fix to remove parentesis and numbers too. remove_quotes([40, _, 41|RestI], RestC) :- remove_quotes(RestI, RestC), !. %remove_quotes([41|RestI], RestC) :- remove_quotes(RestI, RestC), !. remove_quotes([C|RestI], [C|RestC]) :- remove_quotes(RestI, RestC). replace_vars([],[]) :- !. replace_vars([A|RI], [A|RO]) :- atom(A), replace_vars(RI,RO), !. replace_vars([W|RI], [A|RO]) :- term_to_atom(W, A), replace_vars(RI,RO). add_cond(and, Ind1, Ind2, Previous, C4, (C; (C3, C4))) :- last_cond(or, Previous, C, C3), % (C; C3) Ind1 < Ind2, !. add_cond(and, Ind1, Ind2, Previous, C4, ((C; C3), C4)) :- last_cond(or, Previous, C, C3), % (C; C3) Ind1 > Ind2, !. add_cond(and,I, I, (C, C3), C4, (C, (C3, C4))) :- !. add_cond(and,_, _, Cond, RestC, (Cond, RestC)) :- !. add_cond(or, Ind1, Ind2, Previous, C4, (C, (C3; C4))) :- last_cond(and, Previous, C, C3), % (C, C3) Ind1 < Ind2, !. add_cond(or, Ind1, Ind2, Previous, C4, ((C, C3); C4)) :- last_cond(and, Previous, C, C3), % (C, C3) Ind1 > Ind2, !. add_cond(or, I, I, (C; C3), C4, (C; (C3; C4))) :- !. add_cond(or, _, _, Cond, RestC, (Cond; RestC)). last_cond(or, (A;B), A, B) :- B\=(_;_), !. last_cond(or, (C;D), (C;R), Last) :- last_cond(or, D, R, Last). last_cond(and, (A,B), A, B) :- B\=(_,_), !. last_cond(and, (C,D), (C,R), Last) :- last_cond(and, D, R, Last). % adjust_op(Ind1, Ind2, PreviousCond, Op1, Cond2, Op2, Rest, RestMapped, Conditions) % from and to and adjust_op(Ind1, Ind2, C1, and, C2, and, C3, ((C1, C2), C3) ) :- Ind1 =< Ind2, !. adjust_op(Ind1, Ind2, C1, and, C2, and, C3, ((C1, C2), C3) ) :- Ind1 > Ind2, !. % from or to ord adjust_op(Ind1, Ind2, C1, or, C2, or, C3, ((C1; C2); C3) ) :- Ind1 =< Ind2, !. adjust_op(Ind1, Ind2, C1, or, C2, or, C3, ((C1; C2); C3) ) :- Ind1 > Ind2, !. % from and to deeper or adjust_op(Ind1, Ind2, C1, and, C2, or, C3, (C1, (C2; C3)) ) :- Ind1 < Ind2, !. % from deeper or to and adjust_op(Ind1, Ind2, C1, or, C2, and, C3, ((C1; C2), C3) ) :- Ind1 > Ind2, !. % from or to deeper and adjust_op(Ind1, Ind2, C1, or, C2, and, C3, (C1; (C2, C3)) ) :- Ind1 < Ind2, !. % from deeper and to or adjust_op(Ind1, Ind2, C1, and, C2, or, C3, ((C1, C2); C3) ) :- Ind1 > Ind2. operator(and, In, Out) :- and_(In, Out). operator(or, In, Out) :- or_(In, Out). % possible_instance/3 % cuts added to improve efficiency % skipping a list possible_instance([], [], []) :- !. possible_instance(Final, ['['|RestIn], Out) :- !, possible_instance_for_lists(List, RestIn, [']'|Next]), possible_instance(RestW, Next, Out), append(['['|List], [']'|RestW], Final). possible_instance(RestW, [' '|RestIn], Out) :- !, % skip spaces in template possible_instance(RestW, RestIn, Out). possible_instance(RestW, ['\t'|RestIn], Out) :- !, % skip tabs in template possible_instance(RestW, RestIn, Out). possible_instance([that|Instance], In, Out) :- % to allow "that" instances to spread over more than one line phrase(spaces_or_newlines(_), In, [that|Rest]), phrase(spaces_or_newlines(_), Rest, Next), !, possible_instance(Instance, Next, Out). possible_instance([Word|RestW], [Word|RestIn], Out) :- %not(lists:member(Word,['\n', if, and, or, '.', ','])), !, not(lists:member(Word,[newline(_), if, '.', ','])), % leaving the comma in as well (for lists and sets we will have to modify this) possible_instance(RestW, RestIn, Out). possible_instance([], [Word|Rest], [Word|Rest]) :- lists:member(Word,[newline(_), if, '.', ',']). % leaving or/and out of this % using [ and ] for list and set only to avoid clashes for commas %possible_instance_for_lists([], [], []) :- !. possible_instance_for_lists([], [']'|Out], [']'|Out]) :- !. possible_instance_for_lists(RestW, [' '|RestIn], Out) :- !, % skip spaces in template possible_instance_for_lists(RestW, RestIn, Out). possible_instance_for_lists(RestW, ['\t'|RestIn], Out) :- !, % skip tabs in template possible_instance_for_lists(RestW, RestIn, Out). possible_instance_for_lists([Word|RestW], [Word|RestIn], Out) :- %not(lists:member(Word,['\n', if, and, or, '.', ','])), !, possible_instance_for_lists(RestW, RestIn, Out). %possible_instance_for_lists([], [Word|Rest], [Word|Rest]) :- % lists:member(Word,[',', newline(_), if, '.']). % leaving or/and out of this % match_template/4 match_template(PossibleLiteral, Map1, MapN, Literal) :- %print_message(informational,'Possible Meta Literal ~w'-[PossibleLiteral]), meta_dictionary(Predicate, _, MetaCandidate), meta_match(MetaCandidate, PossibleLiteral, Map1, MapN, MetaTemplate), !, meta_dictionary(Predicate, _, MetaTemplate), Literal =.. Predicate. match_template(PossibleLiteral, Map1, MapN, Literal) :- %print_message(informational,'Possible Literal ~w'-[PossibleLiteral]), dictionary(Predicate, _, Candidate), match(Candidate, PossibleLiteral, Map1, MapN, Template), !, dictionary(Predicate, _, Template), Literal =.. Predicate. %print_message(informational,'Match!! with ~w'-[Literal]).% !. % meta_match/5 % meta_match(+CandidateTemplate, +PossibleLiteral, +MapIn, -MapOut, -SelectedTemplate) meta_match([], [], Map, Map, []) :- !. meta_match([Word|_LastElement], [Word|PossibleLiteral], Map1, MapN, [Word,Literal]) :- % asuming Element is last in template! Word = that, % that is a reserved word "inside" templates! -> that