Pliant talk forum

Pliant talk forum

Discussion: Pliant's error messages and their meaning

Message posted by maybe Marcus on 2002/05/15 15:01:10
I was unable to find in Pliant's documentation the explanation of Pliant's
error messages, e.g., how can one identify what is the program line number 
where the error is located.

Suggestion: how about providing more meaningful (for a non experienced Pliant
programmer) error messages?
Message posted by maybe Hubert Tonneau on 2002/05/15 16:06:09
Please post a fiew sample error messages that you fail to understand so that
I write comments.
Message posted by maybe Marcus on 2002/05/15 16:27:13
E.g.: Given the code below which erroneously tries to define a parameterless

method p -> r
  arg Int r
  r:=1

console p 

The (commented) error message:

Failed to compile :=   (Int r  ?) 
# 1-Why specifically the ':=' operator? I was expecting something like:
# 'Method missing first parameter'
# 2- What is semantics of the error expression '(Int r  ?)'?
  compile file:t1.pli (internals) 3 4
# Why 'compile'? What is 'internals'? What is 3? What is 4?
  compile file:t1.pli (internals) 2 1
  compile file:t1.pli (internals) 2 1
  compile file:t1.pli (internals) 1 1
  compile file:t1.pli (internals) 1 1
  compile file:t1.pli (internals) 1 1
  compile file:t1.pli (internals) 1 1
# Why are all the above messages produced?
  parse file:t1.pli (internals) 5 1
# Why 'parse'? Ditto for the numbers.
  module file:t1.pli

Message posted by maybe Marcus on 2002/05/15 16:27:50
E.g.: Given the code below which erroneously tries to define a parameterless

method p -> r
  arg Int r
  r:=1

console p 

The (commented) error message:

Failed to compile :=   (Int r  ?) 
# 1-Why specifically the ':=' operator? I was expecting something like:
# 'Method missing first parameter'
# 2- What is semantics of the error expression '(Int r  ?)'?
  compile file:t1.pli (internals) 3 4
# Why 'compile'? What is 'internals'? What is 3? What is 4?
  compile file:t1.pli (internals) 2 1
  compile file:t1.pli (internals) 2 1
  compile file:t1.pli (internals) 1 1
  compile file:t1.pli (internals) 1 1
  compile file:t1.pli (internals) 1 1
  compile file:t1.pli (internals) 1 1
# Why are all the above messages produced?
  parse file:t1.pli (internals) 5 1
# Why 'parse'? Ditto for the numbers.
  module file:t1.pli

Message posted by maybe Hubert Tonneau on 2002/05/15 17:08:45
With the mistacke

> method p -> r
>   arg Int r
>   r:=1

The problem you have is that Pliant is understanding what you wrote here:
. you are defining method '->'
. the type of the class 'p' is missing.
. the method has an argument 'r' with type 'Int'
in other words, Pliant did not handle '->' as specifying the result, but
rather as beeing the name of the method you are defining because '->' is
a valid identifier.
As a result, 'r' is not the result, but rather an argument, and since you
defined it's type using 'arg' it is assumed to be read-only, wheras it would
automatically be 'read-write' if a result.

> # 1-Why specifically the ':=' operator? I was expecting something like:
> # 'Method missing first parameter'

As stated earlier, there is no missing argument.

> # 2- What is semantics of the error expression '(Int r  ?)'?

':=' failed to compile because it's left argument 'r' is readonly.
The error line is reporting the identifier that failed to compile (here ':=')
then the status of each argument:
There are two arguments for ':=', the first as been compiled to 'Int' with
'r' meaning read-only, and the second has not been compiled yet.

> # Why 'compile'? What is 'internals'? What is 3? What is 4?

Each source file is linked to two modules, one internal containing all
identifiers (rather functions, methods, types, etc) defined in the source
that have not been exported, and one external containing the ones that are
exported. The internal module is marked with 'internals' keyword in order
to distinguish from the external one.
The internal module is discarded when the source file compiling ends.
'3' means line three, '4' means column four.
'compile' means that the error occured while Pliant was attempting to compile.

So, the overall line meaning is error occured when Pliant was compiling
the expression parsed at line three, column four in t1.pli
(the file:t1.pli notation means that you did not lauched Pliant through
a command line like 'pliant module ...' but rather 'pliant t1.pli')

> # Why are all the above messages produced?

When an error occures, all the execution stack is listed top down.

Failed to compile :=   (Int r  ?)  # nothing in the modules included provided something that can compile the ':=' and the reason is that the ':=' definition is expecting a read-write left agument, so it refused to handle this
compile file:t1.pli (internals) 3 4 # compiling the body needs to compile each of it's instruction, including the ':=' at line three
compile file:t1.pli (internals) 2 1
compile file:t1.pli (internals) 2 1 # compiling 'function' needs to compile the body of the function
compile file:t1.pli (internals) 1 1
compile file:t1.pli (internals) 1 1
compile file:t1.pli (internals) 1 1 # compiling often do rewritting, so we can see several time the same node
compile file:t1.pli (internals) 1 1 # since it's a new section, it now tries to compile then execute what it previously parsed. The topmost tree node (Expression) was the 'function' keyword at line 1 column 1
parse file:t1.pli (internals) 5 1 # within t1.pli the parse is reaching line 5 olumn 1
module file:t1.pli # Pliant tries to compile the t1.pli source

Message posted by pom on 2002/05/15 17:09:19
Actually the error is not what you thought!

method p -> r       # seems to be a method '->' on p with parameter r
  arg Int r         # r is an Int
  r := 1            # r is read only, it is not possible to do ':='

Now, the error message:

Failed to compile :=   (Int r  ?) 
 # Try to affect a value to a read only argument
   compile file:t1.pli (internals) 3 4
 # 3 line, 4th column of file t1.pli
 # internal means we were looking at some code which we tried to compile in
 #   the internal part of the module (not the public part). The internal
 # part is usually cleaned up when the module compilation is complete, only
 # the public part remain.
   compile file:t1.pli (internals) 2 1 
   compile file:t1.pli (internals) 2 1
   compile file:t1.pli (internals) 1 1
   compile file:t1.pli (internals) 1 1
   compile file:t1.pli (internals) 1 1
   compile file:t1.pli (internals) 1 1
 # The above is the compilation stack (2,1 -> method; 1,1 -> file)
   parse file:t1.pli (internals) 5 1
 # parsing is always a bit shifted with compilation; it points to the next
 # token we will look for after compilation
   module file:t1.pli


---------------------------

By the way, the following is legal:

method p -> r           # method '->' with one parameter
  arg Int r             # parameter is Int
  console r eol         # print it
  arg Str p             # declaration of the object (I know, it should have
                        # been done before for clarity!)

"coucou" -> 3           # call method '->' on "coucou" with parameter 3

-------------------------------------

The following is also legal:

method p -> -> r       # method -> with no argument, result is r
  arg Int r
  arg Str p
  r := p:len           # r is the result, may be affected

console ("coucou" ->) eol  # call the method on "coucou"
Message posted by maybe Marcus on 2002/05/16 12:11:10
Thanks Hubert and Patrice. Your explanations were enlightening.

I have another suggestion: still refering to that erroneous code

 method p -> r
   arg Int r
   r:=1

I deem it would be more informative if Pliant mentioned in which method/function
definition it has found an error. In the case of the example above, if the error
message started with 

"Error in method '->'"
Followed by the usual Pliant error message.

This would help one determine the nature of the error, because I was in fact
trying to define a parameterless method 'p'.

But then I don't know what would be the implications for the case one is 
compiling a .page program...

Message posted by maybe Marcus on 2002/05/17 20:57:34
The program below produces the following error message:

if 1
  console "true"
else
  console "false"

Failed to compile if   (uInt rc  ?  'else'  ?)

How to interpret the error expression '(uInt rc  ?  'else'  ?)'
Message posted by maybe Hubert Tonneau on 2002/05/17 21:14:01
> Failed to compile if   (uInt rc  ?  'else'  ?)

if 1
  console "true"
else
  console "false"

'if' else is a dual keyword, so it's basically the same as, using a Lisp
like syntax:
(if 1 (console "true") else (console "false"))

The error message means that the 'if' expression failed to compile, that
'if' expression has four arguments, with:
uInt rc  meaning the first argument as been compiled to 'uInt' data type,
         read-only, constant.
?        meaning the second has not been compiled yet.
'else'   meaning the third argument has not been compiled yet, and it is the
         'else' identifier.
?        meaning the fourth argument has not been compiled yet.
Message posted by maybe pom on 2002/05/18 09:20:15
It is quite frequent that the fautive argument is the last one which type
has been identified (here uInt instead of Bool needed by the syntax)
Message posted by maybe Marcus on 2002/06/09 19:50:24
I've noticed that in an error message, the first line can begin as
"Failed to compile ..." 
or
"Failed to parse token ..."

- Is there any other? What does it look like?
Message posted by maybe Hubert Tonneau on 2002/06/09 19:54:39
The first line is the error message provided by the code that tiggered the error.

If you write something like:
  error error_id_unknown "my error"
then the error message will be 'my error'

Message posted by maybe Marcus on 2002/06/09 23:07:52
I have prepared a tentative documentation entitled "Pliant's Default Error
Messages', available at

http://pliant.cx/pliantdocs/babel/universal/errorMessages.html

Members of the core team, please check for inconsistencies and omissions.
Message posted by maybe Hubert Tonneau on 2002/06/09 23:24:42
Maybe you should specify that Pliant debugger is walking the stack so the
first messages are what as just appent (so the more meaning full), and the last
ones are just telling the call sequence that led to the buggy part.
Message posted by maybe Marcus on 2002/06/11 14:14:26
Done. Please check.