How to write a parser in prolog to output a parse tree - parsing

Question

I am writing a parser in prolog that should be able to parse this math formula:
a = 1 * 2 + (3 - 4) / 5;
and print out a parse tree out of it that should look like this:
PARSE TREE:
assignment
ident(a)
assign_op
expression
term
factor
int(1)
mult_op
term
factor
int(2)
add_op
expression
term
factor
left_paren
expression
term
factor
int(3)
sub_op
expression
term
factor
int(4)
right_paren
div_op
term
factor
int(5)
semicolon
I have this function that will print out the parse tree when I run the code run('program1.txt', 'myparsetree1.txt'). which will read the math formula from the program1.txt file and print out the parse tree on the myparsetree1.txt file.
So far I have tried writing this grammar for the parser, but isn't working as I keep getting existence and instantiation error mostly with letter_code and digit_code from the tokenizer whereas prolog complains on too few arguments in it among other things.
/*Loads the tokenizer*/
:- [tokenizer].
parse(I) --> assign(I).
assign(assign(I,'=', Expr,';')) -->
letter_code(I), '=', expr(Expr), ';'.
expr(expr(Term, add_op, Expr)) -->
term(Term), add_op, expr(Expr).
expr(expr(Term, sub_op, Expr)) -->
term(Term), sub_op, expr(Expr).
expr(expr(Term)) --> term(Term).
term(term(Factor, mul_op, Term)) -->
factor(Factor), mul_op, term(Term).
term(term(Factor, div_op, Term)) -->
factor(Factor), div_op, term(Term).
term(term(Factor)) --> factor(Factor).
factor(factor('(', Expr, ')')) --> '(', expr(Expr), ')'.
factor(factor(Digit)) --> digit_code(Digit).
add_op --> ['+'].
sub_op --> ['-'].
mul_op --> ['*'].
div_op --> ['/'].
letter_code and digit_code are predicates from a separate file called tokenizer.pl
digit_code(Code):-
Code >= 48, /* 48 = '0' 57 = '9' */
Code =< 57.
letter_code(Code):-
Code >= 97, /* 97 = 'a' 122 = 'z' */
Code =< 122.
When I run the program I usually get existence error: letter_code/3, same with digit code in which it complains that theere isn't a predicate with 3 arguments. I have tried changing the predicate to have three arguments instead but then I get instantiation error instead. This is what I did and what it results in:
letter_code(Code, Xs, Xs):-
Code >= 97,
Code =< 122.
| ?- run('program1.txt','myparsetree1.txt').
! Existence error in user:letter_code/1
! procedure user:letter_code/1 does not exist
! goal: user:letter_code(97)
//------------------------------------------------
letter_code(Code, Xs, Xs):-
Code >= 97,
Code =< 122.
letter_code(Code):-
Code >= 97,
Code =< 122.
| ?- run('program1.txt','myparsetree1.txt').
! Instantiation error in argument 1 of (>=)/2
! goal: _293>=97
Does anyone know how to resolve this? I hope I made it clearer than when I first postid this question.

Answer 1

In the DCG body, letter_code(C) is going to expand to a call to letter_code/3. Your implementation with three arguments doesn't remove anything from the list, so I think this is not likely to have the effect you want, you probably want something like this instead:
letter_code(Code) -->
[Code],
{
Code >= 97,
Code =< 122
}.
DCG rules expand to predicates with two extra arguments; for instance, listing(letter_code//1) shows this as the parsed value:
?- listing(letter_code//1).
letter_code(A, [A|C], B) :-
A>=97,
A=<122,
B=C.
true.
When you redefined letter_code/3 yourself with letter_code(Code, Xs, Xs) :- ... you should have made something that would compile but fail at runtime. So your issues with not being able to find predicates that you have clearly defined lie somewhere else.

Answer 2

In DCGs, you embed Prolog code bracketing it:
parse(I) --> assign(I).
assign(assign(I,'=', Expr,';')) -->
{letter_code(I)}, '=', expr(Expr), ';'.
...
That is.