mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-16 22:35:41 +00:00
8e0eb72c15
Estimated hours taken: 26
Implement the following improvements:
- Pass mdb variable bindings to the interactive query processor,
allowing queries to make use of live values.
- Catch exceptions thrown by queries, rather than crashing mdb.
- Write outputs using io.write_cc/3.
- Don't output underscore variables, avoiding spurious warnings.
- More protection of the user's namespace.
- Updated the cleanup code.
browser/interactive_query.m:
The interface now accepts corresponding lists of names and values,
which are matched up with variables occurring in the queries.
Replace the code generator with one that supports passing data
to and from the query, and catching exceptions from the query.
Pass the appropriate data at the time the query predicate is called.
Distinguish between failure of the query and failure of the dynamic
casts used to instantiate the query inputs.
Use module qualifiers to avoid clashing with user imports. (Should the
generated code use use_module, just in case?)
Perform I/O, failure handling and exception handling in the caller
instead of in the generated code. This is faster, more maintainable,
and means that errors are caught earlier.
Place source_file and line directives more carefully so as to ensure
more consistent error messages, and to help distinguish errors in the
template from errors in the query.
Factor out the query command parser to avoid double maintenance.
browser/debugger_interface.m:
Conform to above changes.
trace/mercury_trace_vars.[ch]:
Export MR_trace_return_bindings, which constructs Mercury lists
of the variable names and values in the current environment.
trace/mercury_trace_browse.c:
Pass bindings from trace/mercury_trace_vars through to the interactive
query processor.
tests/debugger/interactive.{m,inp,exp}:
Update for changes to existing functionality. Additionally test the
new functionality.
doc/user_guide.texi:
Document the new behaviour.
NEWS:
Announce the new behaviour.
This directory holds the trace subsystem, i.e. the part of the Mercury debugger that is written in C code. Notes on interfacing with other subsystems ------------------------------------------ If tracing is enabled, the compiler includes calls to MR_trace() in the generated C code. The trace subsystem in this directory is therefore called directly from Mercury code, via MR_trace() in runtime/mercury_trace_base.c. One of the first things it does is to save the original values of the Mercury registers in a variable called `saved_regs'. The reason it needs to do this is that the code here may modify registers, e.g. by allocating memory using incr_hp or by calling Mercury code. Once the original values of the registers have been saved, the trace subsystem is free to modify the Mercury registers. So for all code in this directory, the usual convention is that the original values of the Mercury registers are in `saved_regs', while the current (scratch) values for the normal non-transient Mercury registers etc. are in their normal locations, not in the fake_reg copies, and the transient (register window) registers, if any, are in the fake_reg copies. Any code which uses macros such as incr_hp(), list_cons(), make_aligned_string(), etc. that modify the heap pointer must call restore_transient_regs() beforehand and must call save_transient_regs() afterwards. The simplest way to do this is to use the macro MR_TRACE_USE_HP() in trace/mercury_trace_util.h. The tracer may invoke Mercury code defined in the browser or library directories if that code is exported to C using `pragma export'. But any calls from functions here to code defined in Mercury and exported using `pragma export', i.e. functions starting with `ML_' prefixes, must be preceded by a call to save_registers() and followed by a call to restore_registers(). The simplest way to do this is to use the macro MR_TRACE_CALL_MERCURY() in trace/mercury_trace_util.h.