- Documentation
- Reference manual
- Packages
- A C++ interface to SWI-Prolog
- A C++ interface to SWI-Prolog (Version 2)
- Summary of changes between Versions 1 and 2
- Sample code (version 2)
- Introduction (version 2)
- The life of a PREDICATE (version 2)
- Overview (version 2)
- Examples (version 2)
- Rationale for changes from version 1 (version 2)
- Porting from version 1 to version 2
- The class PlFail (version 2)
- Overview of accessing and changing values (version 2)
- The class PlRegister (version 2)
- The class PlQuery (version 2)
- The PREDICATE and PREDICATE_NONDET macros (version 2)
- Exceptions (version 2)
- Embedded applications (version 2)
- Considerations (version 2)
- Conclusions (version 2)
- A C++ interface to SWI-Prolog (Version 2)
- A C++ interface to SWI-Prolog
2.14 Exceptions (version 2)
See also Prolog exceptions in foreign code.
Prolog exceptions are mapped to C++ exceptions using the class
PlException
(a subclass of PlExceptionBase
to
represent the Prolog exception term. All type-conversion functions of
the interface raise Prolog-compliant exceptions, providing decent
error-handling support at no extra work for the programmer.
For some commonly used exceptions, convenience functions have been
created to exploit both their constructors for easy creation of these
exceptions. If you wish to trap these, you should use
PlException
or PlExceptionBase
and then look
for the appropriate error name. For example, the following code catches
"type_error"
and passes all other exceptions:
try { do_something(...); } catch (const PlException& e) { PlTerm e_t = e.term(); PlAtom ATOM_type_error("type_error"); // e_t.name() == PlAtom("error") && e_t.arity() == 2 if ( e_t[1].name() == ATOM_type_error) ) { ... // expected type and culprit are \exam{e_t[1][1]} and \exam{e_t[1][2]} } else throw; }
The convenience functions are PlTypeEror() and PlDomainError(),
PlDomainError(), PlInstantiationError(), PlExistenceError(),
PlUninstantiationError(), PlRepresentationError(),
PlPermissionError(), PlResourceError(), PlUnknownError().
There is also a PlGeneralError(inside) that creates error(inside,_)
terms and is used by the other error convience functions.
To throw an exception, create an instance of PlException
and use throw
. This is intercepted by the PREDICATE macro
and turned into a Prolog exception. See section
2.16.2.
char *data = "users"; throw PlException(PlCompound("no_database", PlTerm(data)));
2.14.1 The class PlException (version 2)
This subclass of PlExceptionBase
is used to represent
exceptions. Currently defined methods are:
- PlException :: PlException(const PlTerm &)
- Create an exception from a general Prolog term. This provides the interface for throwing any Prolog terms as an exception.
- std::string as_string()
- The exception is translated into a message as produced by
print_message/2.
The character data is stored in a ring. Example:
...; try { PlCall("consult(load)"); } catch ( PlException& ex ) { cerr << ex.as_string() << endl; }
- int plThrow()
- Used in the PREDICATE() wrapper
to pass the exception to Prolog. See
PL_raise_exeption().
2.14.1.1 The function PlTypeError (version 2)
A type error expresses that a term does not satisfy the expected basic Prolog type.
- PlTypeError :: PlTypeError(const std::string& expected, const PlTerm &actual)
- Creates an ISO standard Prolog error term expressing the expected type and actual term that does not satisfy this type.
2.14.1.2 The function PlDomainError (version 2)
A domain error expresses that a term satisfies the basic
Prolog type expected, but is unacceptable to the restricted domain
expected by some operation. For example, the standard Prolog open/3
call expect an io_mode
(read, write, append, ...). If an
integer is provided, this is a type error, if an atom other
than one of the defined io-modes is provided it is a domain error.
- PlDomainError :: PlDomainError(const std::string& expected, const PlTerm &actual)
- Creates an ISO standard Prolog error term expressing a the expected domain and the actual term found.