enum PrnType

typedef enum {
    GRETL_PRINT_STDOUT,
    GRETL_PRINT_STDERR,
    GRETL_PRINT_FILE,
    GRETL_PRINT_BUFFER,
    GRETL_PRINT_TEMPFILE,
    GRETL_PRINT_STREAM
} PrnType;

enum PrnFormat

typedef enum {
    GRETL_FORMAT_TXT       = 1 << 0,
    GRETL_FORMAT_TEX       = 1 << 1,
    GRETL_FORMAT_DOC       = 1 << 2,
    GRETL_FORMAT_RTF       = 1 << 3,
    GRETL_FORMAT_RTF_TXT   = 1 << 4,
    GRETL_FORMAT_EQN       = 1 << 5,
    GRETL_FORMAT_SELECTION = 1 << 6,
    GRETL_FORMAT_CSV       = 1 << 7,
    GRETL_FORMAT_TAB       = 1 << 8,
    GRETL_FORMAT_MODELTAB  = 1 << 9,
    GRETL_FORMAT_LANDSCAPE = 1 << 10,
    GRETL_FORMAT_UTF       = 1 << 11
} PrnFormat;

gretl_print_destroy ()

void                gretl_print_destroy                 (PRN *prn);

Close a gretl printing struct and free any associated resources.

gretl_print_new ()

PRN *               gretl_print_new                     (PrnType ptype,
                                                         int *err);

Create and initialize a gretl printing struct. If ptype is GRETL_PRINT_BUFFER, output will go to an automatically resized buffer; if ptype is GRETL_PRINT_STDOUT or GRETL_PRINT_STDERR output goes to stdout or stderr respectively.

If you want a named file associated with the struct, use gretl_print_new_with_filename instead; if you want to attach a fixed, pre-allocated text buffer, use gretl_print_new_with_buffer.

gretl_print_new_with_filename ()

PRN *               gretl_print_new_with_filename       (const char *fname,
                                                         int *err);

Create and initialize a gretl printing struct, with output directed to the named file.

gretl_print_new_with_tempfile ()

PRN *               gretl_print_new_with_tempfile       (int *err);

Create and initialize a gretl printing struct, with output directed to a temporary file, which is deleted when the printing struct is destroyed.

gretl_print_has_tempfile ()

int                 gretl_print_has_tempfile            (PRN *prn);

gretl_print_get_tempfile_name ()

const char *        gretl_print_get_tempfile_name       (PRN *prn);

gretl_print_new_with_buffer ()

PRN *               gretl_print_new_with_buffer         (char *buf);

Creates and initializes a gretl printing struct, with fixed text buffer buf. Fails if buf is NULL. This is a convenience function: you can't use pprintf, pputs or pputc with a printing struct obtained in this way.

Note that buf will be freed if and when gretl_print_destroy is called on the PRN pointer obtained.

gretl_print_new_with_stream ()

PRN *               gretl_print_new_with_stream         (FILE *fp);

Creates and initializes a gretl printing struct, with printing to fp.

Note that fp will be closed if and when gretl_print_destroy is called on the PRN pointer obtained.

gretl_print_detach_stream ()

void                gretl_print_detach_stream           (PRN *prn);

Sets the stream member of prn to NULL so that prn can be destroyed without closing the associated stream. May be used in conjunction with gretl_print_new_with_stream().

gretl_print_reset_buffer ()

int                 gretl_print_reset_buffer            (PRN *prn);

If prn has an attached buffer, write a NUL byte to the start of the buffer and reset the count of bytes printed to zero. The next call to pprintf or similar will then overwite rather than cumulating the printed content.

gretl_print_rename_file ()

int                 gretl_print_rename_file             (PRN *prn,
                                                         const char *oldpath,
                                                         const char *newpath);

If prn is printing to a FILE pointer, rename the file to which it's printing and switch the stream to the new file.

gretl_print_get_buffer ()

const char *        gretl_print_get_buffer              (PRN *prn);

Obtain a pointer to the buffer associated with prn, if any. This pointer must not be modified in any way.

gretl_print_get_trimmed_buffer ()

const char *        gretl_print_get_trimmed_buffer      (PRN *prn);

Obtain a pointer to the buffer associated with prn, if any. This pointer must not be modified in any way. An opening newline is skipped.

gretl_print_steal_buffer ()

char *              gretl_print_steal_buffer            (PRN *prn);

Obtain a pointer to the buffer associated with prn, if any. The pointer on prn itself is set to NULL and the caller takes responsibility for freeing the buffer.

gretl_print_get_size ()

void                gretl_print_get_size                (PRN *prn,
                                                         int *width,
                                                         int *height);

If prn has a non-null buffer attached, provide the width and/or height of the buffer, the width in characters and the height in lines.

gretl_print_read_tempfile ()

FILE *              gretl_print_read_tempfile           (PRN *prn);

Obtain a read handle to the tempfile associated with prn, if any. This should be fclosed once you're finished with it.

gretl_print_stop_tempfile_read ()

int                 gretl_print_stop_tempfile_read      (PRN *prn,
                                                         FILE *fp);

For prn with tempfile attached, stops reading of the tempfile and closes fp (recording the position at which reading stopped).

gretl_print_set_save_position ()

int                 gretl_print_set_save_position       (PRN *prn);

Sets the current buffer offset as the position from which a chunk of the current buffer may be saved, using gretl_print_get_chunk().

gretl_print_unset_save_position ()

void                gretl_print_unset_save_position     (PRN *prn);

Erases the "save position" offset as set by gretl_print_set_save_position().

gretl_print_get_chunk ()

char *              gretl_print_get_chunk               (PRN *prn);

Retrieves a copy of the buffer associated with prn, starting at the offset from the start of the buffer as set by gretl_print_set_save_position().

gretl_print_set_format ()

void                gretl_print_set_format              (PRN *prn,
                                                         PrnFormat format);

Sets the printing format on prn.

gretl_print_toggle_doc_flag ()

void                gretl_print_toggle_doc_flag         (PRN *prn);

Toggles the GRETL_FORMAT_DOC flag on prn.

gretl_print_set_utf_flag ()

void                gretl_print_set_utf_flag            (PRN *prn);

Sets the GRETL_FORMAT_UTF flag on prn.

gretl_print_supports_utf ()

int                 gretl_print_supports_utf            (PRN *prn);

gretl_print_set_delim ()

void                gretl_print_set_delim               (PRN *prn,
                                                         char delim);

Sets the CSV delimiter on prn.

pprintf ()

int                 pprintf                             (PRN *prn,
                                                         const char *format,
                                                         ...);

Multi-purpose printing function: can output to stream, to buffer or to nowhere (silently discarding the output), depending on how prn was initialized. It's not advisable to use this function for large chunks of text: use pputs instead.

pputs ()

int                 pputs                               (PRN *prn,
                                                         const char *s);

pputc ()

int                 pputc                               (PRN *prn,
                                                         int c);

gretl_prn_newline ()

void                gretl_prn_newline                   (PRN *prn);

Print a line break, in the mode appropriate to the format of prn (plain text, TeX or RTF).

gretl_print_flush_stream ()

void                gretl_print_flush_stream            (PRN *prn);

If the output of prn is directed to a stream, flush that stream.

printing_to_standard_stream ()

int                 printing_to_standard_stream         (PRN *prn);

printing_is_redirected ()

int                 printing_is_redirected              (PRN *prn);

print_start_redirection ()

int                 print_start_redirection             (PRN *prn,
                                                         FILE *fp);

Redirects output of prn to fp.

print_end_redirection ()

int                 print_end_redirection               (PRN *prn);

If the output of prn has been diverted relative to its original setting, terminate the redirection.

plain_format ()

int                 plain_format                        (PRN *prn);

rtf_format ()

int                 rtf_format                          (PRN *prn);

rtf_doc_format ()

int                 rtf_doc_format                      (PRN *prn);

tex_format ()

int                 tex_format                          (PRN *prn);

tex_doc_format ()

int                 tex_doc_format                      (PRN *prn);

tex_eqn_format ()

int                 tex_eqn_format                      (PRN *prn);

csv_format ()

int                 csv_format                          (PRN *prn);

prn_format ()

int                 prn_format                          (PRN *prn);

prn_delim ()

char                prn_delim                           (PRN *prn);

gretl_print_has_buffer ()

int                 gretl_print_has_buffer              (PRN *prn);

gretl_print_alloc ()

int                 gretl_print_alloc                   (PRN *prn,
                                                         size_t s);

If prn is using a buffer for printing, try to ensure that at least s bytes are available for further printing. May speed things up if we know there is a large amount of text to be printed.

set_up_verbose_printer ()

PRN *               set_up_verbose_printer              (gretlopt opt,
                                                         PRN *prn);

close_down_verbose_printer ()

void                close_down_verbose_printer          (PRN *vprn);