Checking IP like address list with Prolog - list

Question

I'm trying to build a predicate that given a list (eg. ['1', '2', '3', '.', ... , '2']) it has to recognise it as an IP string in the format (NNN.NNN.NNN.NNN) where N is a digit (between 0 and 9) it return true if it is correctly formatted. It must accept also the case where the IP is only (N.N.N.N or NNN.NNN.N.N and other combinations).
This is what I've done so far
test([X,Y,Z,D | String]) :- digit(X), digit(Y), digit(Z), dot(D), test(String).
Where digit is a list of facts like digit('0'). from 0 to 9; and dot is a fact defined as dot('.'). My code lacks of modularity (it can't recognise single N). Can you help me achieve this?
Thank you!

Answer 1

Welcome to SO. I would do it like this:
seperate the input list into 4 "blocks", where the dot is the delimiter and accept only blocks with 1-3 digit elements in them. To do this prolog can be a bit tricky due to the constraints on the length of the numbers (1-3) and the constraints on the dots (exactly 3 dots). So my approach would look like this (basic but a bit twisted):
test(In):-
digits123(In,['.'|R1]),
digits123(R1,['.'|R2]),
digits123(R2,['.'|R3]),
digits123(R3,[]).
digits123([A,B,C|R],R):-
digit(A),
digit(B),
digit(C).
digits123([A,B|R],R):-
digit(A),
digit(B).
digits123([A|R],R):-
digit(A).
What does it do? digits123/2 gets as input a list and it checks if either the first 3, 2, or one elements are digits. Also the rest of the list is unified with the second argument, making this a test for the numbers and a generator/test for the rest list. digits123/2 alone would be buggy since three digits could be mistaken for 2 or one digit. So the call makes it special: at first digits123/2 is called in the inputlist In, returning the list with the remaining elements. But this remaining list has to start with a dot (['.'|R1]). By writing it like this, R1 is the remaining list without the dot as delimiter. Repeat this two times more to check the 2nd and 3rd block. The last block is different: it has 1-3 digits but no dot (or anything else) afterwards. In other words: there should no elements remain (empty list, []).
Tested with SWISH:
?- test(['1', '2', '3', '.', '2', '3', '.', '2', '.' , '2']).
true;
false.
?- test(['1', '2', '3', '.', '2', '3', '.', '2', '.' ]).
false.

Answer 2

The easies way is to use a DCG grammer to specify what the dotted quad looks like. An IPv4 address is 4 octets, expressed in decimal, and separated by '.'. We can express that as a DCG rule like this:
dotted_quad --> octet, dot, octet, dot, octet, dot, octet.
The rule for a . is trivial:
dot --> ['.'].
The rule(s) for an octet are more complicated. An octet is constrained to be in the domain 0–255. Represented in decimal it can be
0-9:
A single decimal digit 0–9
10-99:
Two decimal digits, the first in the domain 1–9, the second in the domain 0–9.
100-199:
Three decimal digits. The 1st is 1 and the second and third are in the domain 0–9.
200-249:
Three decimal digits. The first is 2, the second has the domain 0–4, and the third, 0–9.
250–255:
Three decimal digits. The first is 2, the second is 5, and the third is constrained to 0–5.
We can either write a lot of special rules to cover this, or add some context to the rule for a decimal digit. Let's add some context to that rule (because why type more than you need to):
digit(D) --> [D].
digit(Min,Max) --> [D], { D #>= Min, D #=< Max }.
These let us say things like digit('0','5') to indicate that a digit in the domain 0-5 is allowed, or digit('2') to say that only the digit 2 is allowed.
Now that we have that we can define the rules for an octet:
octet --> digit('0','9') .
octet --> digit('1','9') , digit('0','9').
octet --> digit('1') , digit('0','9') , digit('0','9').
octet --> digit('2') , digit('0','4') , digit('0','9').
octet --> digit('2') , digit('5') , digit('0','5').
Now we can define our test predicate. All it needs to do is invoke the DCG we defined:
is_dotted_quad(Cs) :- phrase(dotted_quad, Cs).
But since typing something like
[ '1','2','3', '.', '2','3','4', '.', '7','8', '.', '9' ]`
is tedious and error-prone, let's add some conveniences to let us use strings or atoms:
is_dotted_quad(X) :- atom(X) , atom_chars(X,Cs) , is_dotted_quad(Cs) .
is_dotted_quad(X) :- string(X) , atom_chars(X,Cs) , is_dotted_quad(Cs) .
is_dotted_quad(Cs) :- phrase(dotted_quad, Cs).
Putting it all together, you get this:
is_dotted_quad(X) :- atom(X) , atom_chars(X,Cs) , is_dotted_quad(Cs).
is_dotted_quad(X) :- string(X) , string_chars(X,Cs) , is_dotted_quad(Cs).
is_dotted_quad(Cs) :- phrase(dotted_quad, Cs).
dotted_quad --> octet, dot, octet, dot, octet, dot, octet.
dot --> ['.'].
octet --> digit('0','9') .
octet --> digit('1','9') , digit('0','9') .
octet --> digit('1') , digit('0','9') , digit('0','9').
octet --> digit('2') , digit('0','4') , digit('0','9').
octet --> digit('2') , digit('5') , digit('0','5').
digit(V) --> [V].
digit(Min,Max) --> [D], { D #>= Min, D #=< Max }.
You can fiddle with it at https://swish.swi-prolog.org/p/dotted-quad-dcg.pl
Alternatively, if you don't want to use a DCG, then this riff off #Dudas's answer will work as well — but one should be aware that this is essentially what the above DCG is (DCG being an essentially simple bit of syntactic sugar on top of vanilla prolog), just a bit less declarative of intent:
is_dotted_quad(X) :- atom(X) , atom_chars(X,Cs) , is_dotted_quad(Cs).
is_dotted_quad(X) :- string(X) , string_chars(X,Cs) , is_dotted_quad(Cs).
is_dotted_quad(Cs) :- octet(Cs,T1),
dot(T1,T2), octet(T2,T3),
dot(T3,T4), octet(T4,T5),
dot(T5,T6), octet(T6,[]).
chars( [] , [] ) .
chars( [C|Cs] , [C|Cs] ) .
chars( X , Cs ) :- atom(X) , atom_chars(X,Cs) .
chars( X , Cs ) :- string(X) , string_chars(X,Cs) .
dot(['.'|T],T).
octet( [ Z | T ], T ) :- range(Z,'0','9') .
octet( [ Y , Z | T ], T ) :- range(Y,'1','9') , range(Z,'0','9') .
octet( [ '1' , Y , Z | T ], T ) :- range(Y,'0','9') , range(Z,'0','9') .
octet( [ '2' , Y , Z | T ], T ) :- range(Y,'0','4') , range(Z,'0','9') .
octet( [ '2' , '5' , Z | T ], T ) :- range(Z,'0','5') .
range(X,Min,Max) :- X #>= Min, X #=< Max .