78 term_io
%--------------------------------------------------%
% vim: ft=mercury ts=4 sw=4 et
%--------------------------------------------------%
% Copyright (C) 1994-2006, 2009, 2011-2012 The University of Melbourne.
% This file may only be copied under the terms of the GNU Library General
% Public License - see the file COPYING.LIB in the Mercury distribution.
%--------------------------------------------------%
%
% File: term_io.m.
% Main author: fjh.
% Stability: medium to high.
%
% This file encapsulates all the term I/O.
% This exports predicates to read and write terms in the
% nice ground representation provided in term.m.
%
%--------------------------------------------------%
%--------------------------------------------------%
:- module term_io.
:- interface.
:- import_module char.
:- import_module io.
:- import_module ops.
:- import_module stream.
:- import_module term.
:- import_module varset.
%--------------------------------------------------%
:- type read_term(T)
---> eof
; error(string, int)
; term(varset(T), term(T)).
:- type read_term == read_term(generic).
% term_io.read_term(Result, !IO):
%
% Read a term from standard input. Similar to NU-Prolog read_term/2,
% except that resulting term is in the ground representation.
% Binds Result to either `eof', `term(VarSet, Term)', or
% `error(Message, LineNumber)'.
%
:- pred term_io.read_term(read_term(T)::out, io::di, io::uo) is det.
% As above, except uses the given operator table instead of
% the standard Mercury operators.
%
:- pred term_io.read_term_with_op_table(Ops::in, read_term(T)::out,
io::di, io::uo) is det <= op_table(Ops).
% Writes a term to standard output. Uses the variable names specified
% by the varset. Writes _N for all unnamed variables, with N starting at 0.
%
:- pred term_io.write_term(varset(T)::in, term(T)::in, io::di, io::uo) is det.
% As above, except uses the given operator table instead of the
% standard Mercury operators.
%
:- pred term_io.write_term_with_op_table(Ops::in, varset(T)::in, term(T)::in,
io::di, io::uo) is det <= op_table(Ops).
% As above, except it appends a period and new-line.
%
:- pred term_io.write_term_nl(varset(T)::in, term(T)::in, io::di, io::uo)
is det.
% As above, except it appends a period and new-line.
%
:- pred term_io.write_term_nl_with_op_table(Ops::in, varset(T)::in,
term(T)::in, io::di, io::uo) is det <= op_table(Ops).
% Writes a constant (integer, float, string, or atom) to stdout.
%
:- pred term_io.write_constant(const::in, io::di, io::uo) is det.
% Like term_io.write_constant, but return the result in a string.
%
:- func term_io.format_constant(const) = string.
% Writes a variable to stdout.
%
:- pred term_io.write_variable(var(T)::in, varset(T)::in, io::di, io::uo)
is det.
% As above, except uses the given operator table instead of the
% standard Mercury operators.
%
:- pred term_io.write_variable_with_op_table(Ops::in, var(T)::in,
varset(T)::in, io::di, io::uo) is det <= op_table(Ops).
% Given a string S, write S in double-quotes, with characters
% escaped if necessary, to stdout.
%
:- pred term_io.quote_string(string::in, io::di, io::uo) is det.
:- pred term_io.quote_string(Stream::in, string::in,
State::di, State::uo) is det
<= (stream.writer(Stream, string, State),
stream.writer(Stream, char, State)).
% Like term_io.quote_string, but return the result in a string.
%
:- func term_io.quoted_string(string) = string.
% Given an atom-name A, write A, enclosed in single-quotes if necessary,
% with characters escaped if necessary, to stdout.
%
:- pred term_io.quote_atom(string::in, io::di, io::uo) is det.
:- pred term_io.quote_atom(Stream::in, string::in,
State::di, State::uo) is det
<= (stream.writer(Stream, string, State),
stream.writer(Stream, char, State)).
% Like term_io.quote_atom, but return the result in a string.
%
:- func term_io.quoted_atom(string) = string.
% Given a character C, write C in single-quotes,
% escaped if necessary, to stdout.
%
:- pred term_io.quote_char(char::in, io::di, io::uo) is det.
:- pred term_io.quote_char(Stream::in, char::in,
State::di, State::uo) is det
<= (stream.writer(Stream, string, State),
stream.writer(Stream, char, State)).
% Like term_io.quote_char, but return the result in a string.
%
:- func term_io.quoted_char(char) = string.
% Given a character C, write C, escaped if necessary, to stdout.
% The character is not enclosed in quotes.
%
:- pred term_io.write_escaped_char(char::in, io::di, io::uo) is det.
:- pred term_io.write_escaped_char(Stream::in, char::in,
State::di, State::uo) is det
<= (stream.writer(Stream, string, State),
stream.writer(Stream, char, State)).
% Like term_io.write_escaped_char, but return the result in a string.
%
:- func term_io.escaped_char(char) = string.
% A reversible version of escaped_char.
%
:- pred string_is_escaped_char(char, string).
:- mode string_is_escaped_char(in, out) is det.
:- mode string_is_escaped_char(out, in) is semidet.
% Given a string S, write S, with characters escaped if necessary,
% to stdout. The string is not enclosed in quotes.
%
:- pred term_io.write_escaped_string(string::in, io::di, io::uo) is det.
:- pred term_io.write_escaped_string(Stream::in, string::in,
State::di, State::uo) is det
<= (stream.writer(Stream, string, State),
stream.writer(Stream, char, State)).
% Like term_io.write_escaped_char, but return the result in a string.
%
:- func term_io.escaped_string(string) = string.
%--------------------------------------------------%
%--------------------------------------------------%