/****************************************/
%         lire_question(LMots)          */
%   Entrée : question de l'utilisateur  */
/****************************************/

lire_question(LMots) :- convPhrLst(LMots).

% convPhrLst(-ListOfAtomics)
%  Lit l'entrée (read_...), supprime les ponctuations (clean_...)
%  et la convertit en une liste de termes atomiques (extract_...)

convPhrLst(ListOfAtomics) :-
    lectChaine(Str),
    nettChaine(Str, SStr),
    extraireAtomiques(SStr, ListOfAtomics).

% lectChaine(-Chn)                                          ---- VERIFIEE ----
%  Lit le premier caractère d'une chaîne,
%  met le caractère en minuscule et vérifie
%  si ce n'est pas un caractère spécial (\n ou [EF] par ex)

lectChaine(Str) :-
    get0(Ltr),
    enMinuscule(Ltr, LLtr),
    lectSymboles(LLtr, Str).

enMinuscule(X, X).
enMinuscule(X, Y) :-
    X >= 65,
    X =< 90,
    Y is X + 32, !.

lectSymboles(10, []) :- !.  % 10 = Retour à la ligne.
lectSymboles(-1, []) :- !.  % -1 = Caractères ASCII inconnus.
lectSymboles(LLtr, [LLtr|Reste]) :- lectChaine(Reste).

% nettChaine/2                                              ---- VERIFIEE ---
% Lit le type du premier caractère
% et le supprime si c'est un symbole de ponctuation.

nettChaine([L|Str], SStr) :-
    estDeType(L, punctuation),
    nettChaine(Str, SStr), !.

nettChaine([L|Str], [L|SStr]) :-
    nettChaine(Str, SStr), !.

nettChaine([L|[]], []) :-
    estDeType(L, punctuation), !.

nettChaine([L|[]], [L]).

estDeType(46, period) :- !.                         % . (point)
estDeType(X, alphabetic) :- X >= 65, X =< 90, !.    % [A-Z]
estDeType(X, alphabetic) :- X >= 97, X =< 123, !.   % [a-z]
estDeType(X, numeric) :- X >= 48, X =< 57, !.       % [0-9]
estDeType(X, whitespace) :- X =< 32, !.
estDeType(X, punctuation) :- X >= 33, X =< 47, !.
estDeType(X, punctuation) :- X >= 58, X =< 64, !.
estDeType(X, punctuation) :- X >= 91, X =< 96, !.
estDeType(X, punctuation) :- X >= 123, X =< 126, !.
estDeType(_, special).

% extraireAtomiques/2                                       ---- VERIFIEE ----
% Supprime les espaces et
% extrait les mots de la chaîne en les plaçant dans une liste.

extraireAtomiques(SStr, ListOfAtomics) :-
    suppBlancs(SStr, SSStr),
    extraireAtomiquesAux(SSStr, ListOfAtomics).

suppBlancs(X, X).
suppBlancs([C|LChar], Str) :-
    estDeType(C, whitespace), !,
    suppBlancs(LChar, Str).

extraireAtomiquesAux([],[]).
extraireAtomiquesAux([C|LChar], [A|LAtomic]) :-
    extraireMot([C|LChar], Rest, Word),
    chaineVersAtomique(Word, A),
    extraireAtomiques(Rest, LAtomic).

% Déf. d'un mot :
% Suite continue de caractères de même type !
% Ex : 12345 est un mot, abcde est un mot, mais pas a123b !
extraireMot([C|Chars], Rest, [C|RestOfWord]) :-
    estDeType(C, Type),
    extraireMotAux(Type, Chars, Rest, RestOfWord).

extraireMotAux(special, Rest, Rest, []) :- !.
   % if Char is special, don't read more chars.

extraireMotAux(Type, [C|Chars], Rest, [C|RestOfWord]) :-
    estDeType(C, Type), !,
    extraireMotAux(Type, Chars, Rest, RestOfWord).

extraireMotAux(_, Rest, Rest, []).

chaineVersAtomique([C|Chars],Number) :-
    chaineVersNombre([C|Chars],Number), !.

chaineVersAtomique(String,Atom) :- name(Atom,String).

chaineVersNombre(S,N) :-
    chaineVersNombreAux(S,0,N).

chaineVersNombreAux([], Result, Result).
chaineVersNombreAux([D|Digits],ValueSoFar,Result) :-
    digit_value(D,V),
    NewValueSoFar is 10*ValueSoFar + V,
    chaineVersNombreAux(Digits,NewValueSoFar,Result).

digit_value(48,0).
digit_value(49,1).
digit_value(50,2).
digit_value(51,3).
digit_value(52,4).
digit_value(53,5).
digit_value(54,6).
digit_value(55,7).
digit_value(56,8).
digit_value(57,9).