handle.pmc

/*
Copyright (C) 2008-2010, Parrot Foundation.

=head1 NAME

src/pmc/handle.pmc - IO Handle PMC

=head1 DESCRIPTION

This is the base-class for all IO-related PMCs.

=head2 Vtable Functions

=over 4

=item C<init>

=item C<init_pmc>

Handle shouldn't be directly instantiated, init and init_pmc throws
EXCEPTION_INVALID_OPERATION.

=cut

*/

#include "parrot/parrot.h"
#include "../src/io/io_private.h"

/* HEADERIZER HFILE: none */
/* HEADERIZER BEGIN: static */
/* HEADERIZER END: static */

pmclass Handle provides Handle manual_attrs {
    /* TODO: Consider encapsulating PIOHANDLE as a PMC type, for subclassing */
    ATTR PIOHANDLE os_handle;         /* Low level OS descriptor      */
    ATTR INTVAL    record_separator;  /* Record separator (only single char
                                       * supported) */

    VTABLE void init() {
        Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_INVALID_OPERATION,
            "Handle cannot be instantiated directly.");
    }

    VTABLE void init_pmc(PMC * init) {
        Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_INVALID_OPERATION,
            "Handle cannot be instantiated directly.");
    }

/*

=back

=head2 Methods

=over 4

=item C<METHOD isatty()>

Returns a boolean value indicating whether C<SELF> is a console/tty.
This default implementation always return false. Override it in
subtypes that are or can be tty.

=cut

*/

    METHOD isatty() {
        RETURN(INTVAL 0);
    }

/*

=item C<METHOD get_fd()>

Retrieve the integer file descriptor for the Handle (only available on
platforms that use integer file descriptors).

=cut

*/

    METHOD get_fd() {
        PIOHANDLE os_handle;
        INTVAL    fd;
        GET_ATTR_os_handle(INTERP, SELF, os_handle);
        fd = (INTVAL)os_handle;
        RETURN(INTVAL fd);
    }


/*

=item C<METHOD read(INTVAL bytes)>

Read the given number of bytes from the handle and return them in a string.

=cut

*/

    METHOD read(INTVAL length) {
        STRING * const string_result = Parrot_io_reads(INTERP, SELF, length);
        RETURN(STRING *string_result);
    }


/*

=item C<METHOD readline()>

Read a line from the handle and return it in a string.

=cut

*/

    METHOD readline() {
        STRING * const string_result = Parrot_io_readline(INTERP, SELF);
        RETURN(STRING *string_result);
    }


/*

=item C<METHOD record_separator()>

Set the record separator for readline.

=cut

*/

    METHOD record_separator(STRING *str :optional, int has_str :opt_flag) {
        INTVAL c;

        if (has_str) {
            if (STRING_length(str) != 1)
                Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_INVALID_OPERATION,
                    "Record separator must be a single character");

            c = STRING_ord(interp, str, 0);
            SET_ATTR_record_separator(INTERP, SELF, c);
        }
        else {
            GET_ATTR_record_separator(INTERP, SELF, c);
            str = Parrot_str_chr(interp, c);
        }

        RETURN(STRING *str);
    }


/*

=item C<METHOD close()>

Close the handle.

=cut

*/

    METHOD close() {
        const INTVAL status = Parrot_io_close_handle(INTERP, SELF);
        RETURN(INTVAL status);
    }

}

/*
 * Local variables:
 *   c-file-style: "parrot"
 * End:
 * vim: expandtab shiftwidth=4 cinoptions='\:2=2' :
 */