Ciao Preprocessor (integrated Alpha version)
 | This is an alpha distribution, meant only for testing. Please do let us 
 | know at ciaopp-bugclip.dia.fi.upm.es any problems you may have.

{Reading /tmp/tmp56tmBa/rdtok.pl
}
{In /tmp/tmp56tmBa/rdtok.pl
{loaded in 3452.217 msec.}
{preprocessed for plai in 8.001 msec.}
{analyzed by plai using det with local-control off in 100.006 msec.}
{written file /tmp/tmp56tmBa/rdtok_det_co.pl}
:- module(_1,[read_tokens/2],[assertions]).

goal :-
        read_tokens(TokenList,Dict).

:- entry read_tokens(A,B).

:- true pred read_tokens(A,B)
         : ( native_props:mshare([[A],[A,B],[B]]), term(A), term(B) )
        => ( ground([A,B]), rt34(A), rt35(B) )
         + ( is_det, mut_exclusive ).

read_tokens(TokenList,Dictionary) :-
        read_tokens(32,Dict,ListOfTokens),
        append(Dict,[],Dict),
        !,
        Dictionary=Dict,
        TokenList=ListOfTokens.
read_tokens([atom(end_of_file)],[]).

:- true pred read_tokens(Ch,_X,_Y)
         : ( native_props:mshare([[_X],[_Y]]), var(_X), var(_Y), ground([Ch]), rt1(Ch), term(_X), term(_Y) )
         + fails.

:- true pred read_tokens(32,_X,_Y)
         : ( native_props:mshare([[_X],[_Y]]), var(_X), var(_Y), term(_X), term(_Y) )
         + fails.

:- true pred read_tokens(Ch,_X,_Y)
         : ( native_props:mshare([[_X],[_Y]]), var(_Y), ground([Ch]), rt1(Ch), rt16(_X), term(_Y) )
         + fails.

read_tokens(-1,_X,_Y) :-
        !,
        fail.
read_tokens(Ch,Dict,Tokens) :-
        Ch=<32,
        !,
        rdtok:get0(NextCh),
        read_tokens(NextCh,Dict,Tokens).
read_tokens(37,Dict,Tokens) :-
        !,
        repeat,
        rdtok:get0(Ch),
        'read_tokens/3/3/$disj/1'(Ch),
        !,
        Ch=\= -1,
        rdtok:get0(NextCh),
        read_tokens(NextCh,Dict,Tokens).
read_tokens(47,Dict,Tokens) :-
        !,
        rdtok:get0(NextCh),
        read_solidus(NextCh,Dict,Tokens).
read_tokens(33,Dict,[atom(!)|Tokens]) :-
        !,
        rdtok:get0(NextCh),
        read_after_atom(NextCh,Dict,Tokens).
read_tokens(40,Dict,[' ('|Tokens]) :-
        !,
        rdtok:get0(NextCh),
        read_tokens(NextCh,Dict,Tokens).
read_tokens(41,Dict,[')'|Tokens]) :-
        !,
        rdtok:get0(NextCh),
        read_tokens(NextCh,Dict,Tokens).
read_tokens(44,Dict,[','|Tokens]) :-
        !,
        rdtok:get0(NextCh),
        read_tokens(NextCh,Dict,Tokens).
read_tokens(59,Dict,[atom(;)|Tokens]) :-
        !,
        rdtok:get0(NextCh),
        read_tokens(NextCh,Dict,Tokens).
read_tokens(91,Dict,['['|Tokens]) :-
        !,
        rdtok:get0(NextCh),
        read_tokens(NextCh,Dict,Tokens).
read_tokens(93,Dict,[']'|Tokens]) :-
        !,
        rdtok:get0(NextCh),
        read_tokens(NextCh,Dict,Tokens).
read_tokens(123,Dict,['{'|Tokens]) :-
        !,
        rdtok:get0(NextCh),
        read_tokens(NextCh,Dict,Tokens).
read_tokens(124,Dict,['|'|Tokens]) :-
        !,
        rdtok:get0(NextCh),
        read_tokens(NextCh,Dict,Tokens).
read_tokens(125,Dict,['}'|Tokens]) :-
        !,
        rdtok:get0(NextCh),
        read_tokens(NextCh,Dict,Tokens).
read_tokens(46,Dict,Tokens) :-
        !,
        rdtok:get0(NextCh),
        read_fullstop(NextCh,Dict,Tokens).
read_tokens(34,Dict,[string(S)|Tokens]) :-
        !,
        read_string(S,34,NextCh),
        read_tokens(NextCh,Dict,Tokens).
read_tokens(39,Dict,[atom(A)|Tokens]) :-
        !,
        read_string(S,39,NextCh),
        name(A,S),
        read_after_atom(NextCh,Dict,Tokens).
read_tokens(Ch,Dict,[var(Var,Name)|Tokens]) :-
        'read_tokens/3/18/$disj/1'(Ch),
        !,
        read_name(Ch,S,NextCh),
        'read_tokens/3/18/$disj/2'(Dict,Var,Name,S),
        !,
        read_tokens(NextCh,Dict,Tokens).
read_tokens(Ch,Dict,[integer(I)|Tokens]) :-
        Ch>=48,
        Ch=<57,
        !,
        read_integer(Ch,I,NextCh),
        read_tokens(NextCh,Dict,Tokens).
read_tokens(Ch,Dict,[atom(A)|Tokens]) :-
        Ch>=97,
        Ch=<122,
        !,
        read_name(Ch,S,NextCh),
        name(A,S),
        read_after_atom(NextCh,Dict,Tokens).
read_tokens(Ch,Dict,[atom(A)|Tokens]) :-
        rdtok:get0(AnotherCh),
        read_symbol(AnotherCh,Chars,NextCh),
        name(A,[Ch|Chars]),
        read_after_atom(NextCh,Dict,Tokens).

'read_tokens/3/3/$disj/1'(Ch) :-
        Ch=10.
'read_tokens/3/3/$disj/1'(Ch) :-
        Ch= -1.

:- true pred 'read_tokens/3/18/$disj/1'(Ch)
         : ( ground([Ch]), rt1(Ch) )
        => ( ground([Ch]), rt1(Ch) )
         + ( is_det, mut_exclusive ).

'read_tokens/3/18/$disj/1'(Ch) :-
        Ch=95.
'read_tokens/3/18/$disj/1'(Ch) :-
        Ch>=65,
        Ch=<90.

:- true pred 'read_tokens/3/18/$disj/2'(Dict,Var,Name,S)
         : ( native_props:mshare([[Dict],[Var],[Name]]), var(Dict), var(Var), var(Name), ground([S]), term(Dict), term(Var), term(Name), rt3(S) )
        => ( native_props:mshare([[Dict],[Dict,Var]]), ground([Name,S]), rt16(Dict), term(Var), constant(Name), rt3(S) )
         + ( is_det, mut_exclusive ).

:- true pred 'read_tokens/3/18/$disj/2'(Dict,Var,Name,S)
         : ( native_props:mshare([[Dict],[Var],[Name]]), var(Var), var(Name), ground([S]), rt16(Dict), term(Var), term(Name), rt3(S) )
        => ( native_props:mshare([[Dict],[Dict,Var]]), ground([Name,S]), rt29(Dict), term(Var), constant(Name), rt3(S) )
         + ( is_det, mut_exclusive ).

'read_tokens/3/18/$disj/2'(Dict,Var,Name,S) :-
        S="_",
        Name='_'.
'read_tokens/3/18/$disj/2'(Dict,Var,Name,S) :-
        name(Name,S),
        read_lookup(Dict,Name=Var).

:- true pred read_after_atom(Ch,Dict,Tokens)
         : ( native_props:mshare([[Dict],[Tokens]]), var(Tokens), ground([Ch]), rt1(Ch), rt16(Dict), term(Tokens) )
         + fails.

:- true pred read_after_atom(Ch,Dict,Tokens)
         : ( native_props:mshare([[Dict],[Tokens]]), var(Dict), var(Tokens), ground([Ch]), rt1(Ch), term(Dict), term(Tokens) )
         + fails.

read_after_atom(40,Dict,['('|Tokens]) :-
        !,
        rdtok:get0(NextCh),
        read_tokens(NextCh,Dict,Tokens).
read_after_atom(Ch,Dict,Tokens) :-
        read_tokens(Ch,Dict,Tokens).

read_string(Chars,Quote,NextCh) :-
        rdtok:get0(Ch),
        read_string(Ch,Chars,Quote,NextCh).

read_string(-1,_N,Quote,-1) :-
        display('! end of file in '),
        rdtok:ttyput(Quote),
        display(token),
        rdtok:ttyput(Quote),
        rdtok:ttynl,
        !,
        fail.
read_string(Quote,Chars,Quote,NextCh) :-
        !,
        rdtok:get0(Ch),
        more_string(Ch,Quote,Chars,NextCh).
read_string(Char,[Char|Chars],Quote,NextCh) :-
        read_string(Chars,Quote,NextCh).

more_string(Quote,Quote,[Quote|Chars],NextCh) :-
        !,
        read_string(Chars,Quote,NextCh).
more_string(NextCh,_1,[],NextCh).

read_solidus(42,Dict,Tokens) :-
        !,
        rdtok:get0(Ch),
        read_solidus(Ch,NextCh),
        read_tokens(NextCh,Dict,Tokens).
read_solidus(Ch,Dict,[atom(A)|Tokens]) :-
        read_symbol(Ch,Chars,NextCh),
        name(A,"/"||Chars),
        read_tokens(NextCh,Dict,Tokens).

read_solidus(-1,-1) :-
        !,
        display('! end of file in /*comment'),
        rdtok:ttynl.
read_solidus(42,LastCh) :-
        rdtok:get0(NextCh),
        NextCh=\=47,
        !,
        read_solidus(NextCh,LastCh).
read_solidus(42,32) :- !.
read_solidus(_N,LastCh) :-
        rdtok:get0(NextCh),
        read_solidus(NextCh,LastCh).

:- true pred read_name(Char,_1,LastCh)
         : ( native_props:mshare([[_1],[LastCh]]), var(_1), var(LastCh), ground([Char]), rt1(Char), term(_1), term(LastCh) )
        => ( ground([Char,_1,LastCh]), rt1(Char), rt3(_1), rt1(LastCh) )
         + ( is_det, mut_exclusive ).

read_name(Char,[Char|Chars],LastCh) :-
        'read_name/3/1/$disj/1'(Char),
        !,
        rdtok:get0(NextCh),
        read_name(NextCh,Chars,LastCh).
read_name(LastCh,[],LastCh).

:- true pred 'read_name/3/1/$disj/1'(Char)
         : ( ground([Char]), rt1(Char) )
        => ( ground([Char]), rt1(Char) )
         + ( non_det, not_mut_exclusive ).

'read_name/3/1/$disj/1'(Char) :-
        Char>=97,
        Char=<122.
'read_name/3/1/$disj/1'(Char) :-
        Char>=65,
        Char=<90.
'read_name/3/1/$disj/1'(Char) :-
        Char>=48,
        Char=<57.
'read_name/3/1/$disj/1'(Char) :-
        Char=95.

read_symbol(Char,[Char|Chars],LastCh) :-
        member(Char,"#$&*+-./:<=>?@^`~"),
        rdtok:get0(NextCh),
        read_symbol(NextCh,Chars,LastCh).
read_symbol(LastCh,[],LastCh).

read_fullstop(-1,_X,_Y) :-
        !,
        display('! end of file just after full stop'),
        rdtok:ttynl,
        fail.
read_fullstop(Ch,_N,[]) :-
        Ch=<32,
        !.
read_fullstop(Ch,Dict,[atom(A)|Tokens]) :-
        read_symbol(Ch,S,NextCh),
        name(A,"."||S),
        read_tokens(NextCh,Dict,Tokens).

:- true pred read_integer(BaseChar,IntVal,NextCh)
         : ( native_props:mshare([[IntVal],[NextCh]]), var(IntVal), var(NextCh), ground([BaseChar]), rt1(BaseChar), term(IntVal), term(NextCh) ).

read_integer(BaseChar,IntVal,NextCh) :-
        Base is BaseChar-48,
        rdtok:get0(Ch),
        Ch=\= -1,
        'read_integer/3/1/$disj/1'(IntVal,NextCh,Base,Ch),
        !.

'read_integer/3/1/$disj/1'(IntVal,NextCh,Base,Ch) :-
        Ch=\=39,
        read_digits(Ch,Base,10,IntVal,NextCh).
'read_integer/3/1/$disj/1'(IntVal,NextCh,Base,Ch) :-
        Base>=1,
        read_digits(0,Base,IntVal,NextCh).
'read_integer/3/1/$disj/1'(IntVal,NextCh,Base,Ch) :-
        rdtok:get0(IntVal),
        IntVal=\= -1,
        rdtok:get0(NextCh).

read_digits(SoFar,Base,Value,NextCh) :-
        rdtok:get0(Ch),
        Ch=\= -1,
        read_digits(Ch,SoFar,Base,Value,NextCh).

read_digits(Digit,SoFar,Base,Value,NextCh) :-
        Digit>=48,
        Digit=<57,
        !,
        Next is SoFar*Base-48+Digit,
        read_digits(Next,Base,Value,NextCh).
read_digits(LastCh,Value,_1,Value,LastCh).

:- true pred read_lookup(_1,_2=_3)
         : ( native_props:mshare([[_1],[_3]]), var(_3), ground([_2]), term(_1), constant(_2), term(_3) )
        => ( native_props:mshare([[_1],[_1,_3]]), ground([_2]), rt29(_1), constant(_2), term(_3) )
         + ( is_det, mut_exclusive ).

:- true pred read_lookup(_1,X)
         : ( native_props:mshare([[_1],[X]]), term(_1), rt21(X) )
        => ( native_props:mshare([[_1],[_1,X]]), rt25(_1), rt21(X) )
         + ( is_det, mut_exclusive ).

:- true pred read_lookup(_1,_2=_3)
         : ( native_props:mshare([[_1],[_3]]), var(_1), var(_3), ground([_2]), term(_1), constant(_2), term(_3) )
        => ( native_props:mshare([[_1],[_1,_3]]), ground([_2]), rt16(_1), constant(_2), term(_3) )
         + ( is_det, mut_exclusive ).

:- true pred read_lookup(_1,X)
         : ( native_props:mshare([[_1],[X]]), var(_1), term(_1), rt8(X) )
        => ( native_props:mshare([[_1],[_1,X]]), rt12(_1), rt8(X) )
         + ( is_det, mut_exclusive ).

read_lookup([X|_1],X) :- !.
read_lookup([_M|T],X) :-
        read_lookup(T,X).

member(X,[X|_1]).
member(X,[_M|L]) :-
        member(X,L).

append([],Y,Y).
append([A|X],Y,[A|Z]) :-
        append(X,Y,Z).


:- regtype rt1/1.

rt1(32).


:- regtype rt17/1.

rt17(A) :-
        term(A).


:- regtype rt16/1.

rt16([A|B]) :-
        term(A),
        rt17(B).


:- regtype rt34/1.

rt34([atom(end_of_file)]).


:- regtype rt35/1.

rt35([]).


:- regtype rt3/1.

rt3([]).


:- regtype rt30/1.

rt30(A) :-
        term(A).


:- regtype rt29/1.

rt29([A|B]) :-
        term(A),
        rt30(B).


:- regtype rt21/1.

rt21(A=B) :-
        constant(A),
        term(B).


:- regtype rt26/1.

rt26(A) :-
        term(A).
rt26([A|B]) :-
        term(A),
        rt26(B).


:- regtype rt25/1.

rt25([A|B]) :-
        term(A),
        rt26(B).


:- regtype rt8/1.

rt8(A=B) :-
        constant(A),
        term(B).


:- regtype rt13/1.

rt13(A) :-
        term(A).
rt13([A|B]) :-
        term(A),
        rt13(B).


:- regtype rt12/1.

rt12([A|B]) :-
        term(A),
        rt13(B).