:- import ins/1, asrt/1, db/1 from updates.
:- import wff/2 from parser.
:- import append/3 from basics.

 

% The "updatable" operator can only be used in database programs

% to declare the predicates representing tables that allow updates.

%

:- op(500, fx, [updatable]).

 

% A transaction program is stored in a file with the name of the

% form "name.ctr". The "comp_trans" command takes the "name" as

% argument, reads and parses the transaction program line by line

% creating the output as "name.ctr.o"; the rules written in the output

% file are then loaded into the transaction base.

%

comp_trans(File) :-
                in_filename(File,File1),
                see(File1),
                out_filename(File1,FileOut),
                unix('rm -f FileOut 2>/dev/null', R1),
                tell(FileOut),
                repeat_read_and_compile(File1,FileOut),
                seen, told.
               insert_file(FileOut).

 

% The input file is read and processed recursively until

% the end of file is reached.

%

repeat_read_and_compile(FileIn,FileOut) :-
        read(Term),
        (
        (Term == end_of_file) -> true
        ;
        read_and_write_rule(Term,FileIn,FileOut),
        repeat_read_and_compile(FileIn,FileOut)  ).

 

% To translate a rule from the transaction program, the head

% of the rule becomes trans(head) and the remainder of the rule

% does not change.

%

% For each rule, a new rule is created with the form head :- fail,

% to let Prolog know that the corresponding predicate is defined.

% The translated rule and the new rule associated to it are written

% in the output file.

%

read_and_write_rule(':-'(Lhs,Rhs),_,_) :-
        write('trans('),
        write(Lhs),
        write(')'),
        write(' :-  '),
        wff(Rhs, PRhs),
        write(PRhs),
        write('.'), nl,
        write(Lhs),
        write(' :- fail.'), nl.

 

% If the transaction is an atom then it is just copied to

% the output file.

%

read_and_write_rule(Term,_,_) :-
        not(Term = ':-'(_,_)),
        write(Term),
        write('.'), nl.

 

% A database program is stored in a file with the name of the

% form "name.db". The "name" has to be the same with the

% corresponding transaction program "name".

%

% The "comp_db" command takes the "name" as argument, reads

% and parses the database program line by line creating the output

% as "name.db.o"; the rules written in the output file are then

% inserted into the database.

%

comp_db(File) :-
                db_filename(File,File2),
                see(File2),
                read(Term),
                tmp_filename(File,File3),
                unix('rm -f File3 2>/dev/null', R1),
                tell(File3),
                write_a_line(Term,File2,File3),
                seen,
                told,
                see(File3),
                read(T),
                load_a_line(T,File3),
                seen.

 

% Any "updatable" declaration of a predicate "p" is translated

% to "p(X) = db(p(X))" and written into the output file.

%

write_a_line(updatable(Name/Num),File2,File3) :-
                db_mod(Name,Num,Arg),
                write(Arg), nl,
                db_ins(Name,Num,Argi),
                write(Argi), nl,
                read(Next), !,
                write_a_line(Next,File2,File3).

 

% The database rules are just copied to the output file.

%

write_a_line((Lhs :- Rhs),File2,File3) :-
                write(Lhs),
                write(' :- '),
                write(Rhs),
                write('.'), nl,
                read(Next), !,
                write_a_line(Next,File2,File3).

 

% If the input line contains an atom, then it is copied to the

% output file and inserted into the database.

%

write_a_line(Term,File2,File3) :-
                not(Term = updatable(_)),
                write_and_assert(Term,File2,File3).

write_and_assert(Term,File2,File3) :-
                (Term == end_of_file), !, true
                ;
                write(Term),
                write('.'), nl,
                read(Next), !,
                write_a_line(Next,File2,File3).

 

% For each "updatable" predicate "p", a tuple with the form

% "modif(p)" is inserted into the database.

%

oad_a_line(modif(P),File3) :-
                asrt(P),
                read(Next), !,
                load_a_line(Next,File3).

% The rules are inserted into the database
%
load_a_line((Lhs :- Rhs),File3) :-
                assert((Lhs :- Rhs)),
                read(Next), !,
                load_a_line(Next,File3).

 

% The database tuples are inserted into the database using

% "strong inserts". This type of inserts is implemented in the

% "updates" module and ensures that the database is not corrupted

% during backtracking.

%

load_a_line(Term,File3) :-
                not(Term = modif(_)),
                read_and_assert(Term,File3).

read_and_assert(Term,File3) :-
                (Term == end_of_file), !, true
                ;
                ins(Term),
                read(Next), !,
                load_a_line(Next,File3).

 

% For an updatable predicate, p, the clause "p(X) = db(p(X))"

% is built.

%

db_ins(Name,Num,Argj) :- name(Name,Namel),
                        db_name(Namel,Name1),
                        db_arg(Name1,Num,Argj).
 

db_name(Namel,Name1) :- append(Namel,"(",Name1).

db_arg(Name1,0,Argj) :- append(Name1,")",Arg1),
                       append(Arg1," :- db(",Arg2),
                       append(Arg2,Arg1,Arg3),
                       append(Arg3,").",Argl),
                       name(Argj,Argl).

db_arg(Name1,Num,Argj) :- name(Num,L),
                         append("X",L,Argi),
                         append(Name1,Argi,Tmp1),
                         Num1 is Num - 1,
                         (Num1 = 0,
                         db_arg(Tmp1,Num1,Argj)
                         ;
                         append(Tmp1,",",Tmp2),
                         db_arg(Tmp2,Num1,Argj)).

 

% For each updatable predicate, p, the tuple "modif(p(X))"

% is created for insertion into the database.

%

db_mod(Name,Num,Arg) :- name(Name,Namel),
                        db_name1(Namel,Name1),
                        db_arg1(Name1,Num,Arg).
 

db_name1(Namel,Name1) :- append("modif(",Namel,Namel1),
                         append(Namel1,"(",Name1).

db_arg1(Name1,0,Arg) :- append(Name1,")).",Arg1),
                        name(Arg,Arg1).

db_arg1(Name1,Num,Arg) :- name(Num,L),
                          append("X",L,Argi),
                          append(Name1,Argi,Tmp1),
                          Num1 is Num - 1,
                          (Num1 = 0,
                          db_arg1(Tmp1,Num1,Arg)
                          ;
                          append(Tmp1,",",Tmp2),
                          db_arg1(Tmp2,Num1,Arg)).

 

% The transaction and database program file names are

% created based on the arguments entered in "comp_trans" and

% "comp_db" commands. These names are required to read and

% write the files.

%

in_filename(FileIn,FileOut) :-
        name(FileIn,NameIn),
        append(NameIn,".ctr",NameOut),
        name(FileOut,NameOut).

out_filename(FileIn,FileOut) :-
        name(FileIn,NameIn),
        append(NameIn,".o",NameOut),
        name(FileOut,NameOut).

db_filename(FileIn,FileOut) :-
        name(FileIn,NameIn),
        append(NameIn,".db",NameOut),
        name(FileOut,NameOut).

tmp_filename(FileIn,FileOut) :-
        name(FileIn,NameIn),
        append(NameIn,".db.o",NameOut),
        name(FileOut,NameOut).

 

% The translated transaction program is inserted into the

% transaction base line by line.

insert_file(FileName) :-
        seeing(X),
        see(FileName),
        read_and_add_line,
        see(X).

read_and_add_line :-
        read(Line),
        (
        (Line == end_of_file)   -> true
        ;
        assert(Line),
        read_and_add_line ).