source: libcfa/src/strstream.cfa@ b28ce93

//
// Cforall Version 1.0.0 Copyright (C) 2021 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// strstream.cfa --
//
// Author           : Peter A. Buhr
// Created On       : Thu Apr 22 22:24:35 2021
// Last Modified By : Peter A. Buhr
// Last Modified On : Mon Apr 14 20:45:00 2025
// Update Count     : 116
//

#include "strstream.hfa"
#include "fstream.hfa"                                                                  // abort

#include <stdio.h>                                                                              // vsnprintf
#include <stdarg.h>                                                                             // varargs
#include <string.h>                                                                             // strncpy, strerror
#include <assert.h>
#include <errno.h>                                                                              // errno
#include <unistd.h>                                                                             // sbrk, sysconf

#pragma GCC visibility push(default)

// *********************************** strstream ***********************************

static basic_ostream_data(ostrstream) ostrstream_basic_data = {
        sepPrt$,
        sepReset$,
        sepReset$,
        sepGetCur$,
        sepSetCur$,
        getNL$,
        setNL$,
        getANL$,
        setANL$,
        getPrt$,
        setPrt$,
        nlOn,
        nlOff,
        sep,
        nosep,
        sepOn,
        sepOff,
        sepGet,
        sepSet,
        sepGetTuple,
        sepSetTuple,
        ends,
        fmt,
};

basic_ostream_data(ostrstream) const & basic_ostream_table = ostrstream_basic_data;

#define IO_MSG "I/O error: "

// private
inline bool getNL$( ostrstream & os ) { return os.sawNL$; }
inline bool setNL$( ostrstream & os, bool state ) { bool temp = os.sawNL$; os.sawNL$ = state; return temp; }
inline bool getANL$( ostrstream & os ) { return os.nlOnOff$; }
inline bool setANL$( ostrstream & os, bool state ) { bool temp = os.nlOnOff$; os.nlOnOff$ = state; return temp; }
inline bool sepPrt$( ostrstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
inline void sepReset$( ostrstream & os ) { os.sepOnOff$ = os.sepDefault$; }
inline void sepReset$( ostrstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
inline const char * sepGetCur$( ostrstream & os ) { return os.sepCur$; }
inline void sepSetCur$( ostrstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
inline bool getPrt$( ostrstream & os ) { return os.prt$; }
inline bool setPrt$( ostrstream & os, bool state ) { bool temp = os.prt$; os.prt$ = state; return temp; }

// public
void nlOn( ostrstream & os ) { os.nlOnOff$ = true; }
void nlOff( ostrstream & os ) { os.nlOnOff$ = false; }

void ?{}( ostrstream & os, char buf[], size_t size ) {
        os.buf$ = buf;
        os.size$ = size;
        os.cursor$ = 0;
        os.sepDefault$ = true;
        os.sepOnOff$ = false;
        os.nlOnOff$ = true;
        os.prt$ = false;
        os.sawNL$ = false;
        sepSetCur$( os, sepGet( os ) );
        sepSet( os, " " );
        sepSetTuple( os, ", " );
} // ?{}

void sep( ostrstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
void nosep( ostrstream & os ) { os.sepOnOff$ = false; }

bool sepOn( ostrstream & os ) {
        bool temp = os.sepDefault$;
        os.sepDefault$ = true;
        if ( os.sepOnOff$ ) sepReset$( os );                            // start of line ?
        return temp;
} // sepOn

bool sepOff( ostrstream & os ) {
        bool temp = os.sepDefault$;
        os.sepDefault$ = false;
        sepReset$( os );
        return temp;
} // sepOff

const char * sepGet( ostrstream & os ) { return os.separator$; }
void sepSet( ostrstream & os, const char s[] ) {
        assert( s );
        strncpy( os.separator$, s, ostrstream_sepSize - 1 );
        os.separator$[ostrstream_sepSize - 1] = '\0';
} // sepSet

const char * sepGetTuple( ostrstream & os ) { return os.tupleSeparator$; }
void sepSetTuple( ostrstream & os, const char s[] ) {
        assert( s );
        strncpy( os.tupleSeparator$, s, ostrstream_sepSize - 1 );
        os.tupleSeparator$[ostrstream_sepSize - 1] = '\0';
} // sepSet

void ends( ostrstream & os ) {
        if ( getANL$( os ) ) nl( os );
        else setPrt$( os, false );                                                      // turn off
} // ends

int fmt( ostrstream & os, const char format[], ... ) {
        va_list args;
        va_start( args, format );
        int len = vsnprintf( os.buf$ + os.cursor$, os.size$ - os.cursor$, format, args );
        va_end( args );
        os.cursor$ += len;
        if ( os.cursor$ >= os.size$ ) {                                         // cursor exceeded buffer size?
                #define fmtmsg IO_MSG "ostrstream truncated write, buffer too small.\n"
                write( STDERR_FILENO, fmtmsg, sizeof(fmtmsg) - 1 );
                abort();
        } // if

        setPrt$( os, true );                                                            // called in output cascade
        sepReset$( os );                                                                        // reset separator
        return len;
} // fmt

ostrstream & write( ostrstream & os, FILE * stream ) {
        if ( fwrite( os.buf$, 1, os.cursor$, stream ) != os.cursor$ ) {
                #define ostrwritemsg IO_MSG "ostrstream write error.\n"
                write( STDERR_FILENO, ostrwritemsg, sizeof(ostrwritemsg) - 1 );
                abort();
        } // if
        return os;
} // write

ostrstream & write( ostrstream & os ) {
        return write( os, stdout );
} // write


// *********************************** istrstream ***********************************

static basic_istream_data(istrstream) istrstream_basic_data = {
        getANL$,
        setANL$,
        nlOn,
        nlOff,
        fmt,
        ungetc,
        eof,
        clearerr,
};

basic_istream_data(istrstream) const & basic_istream_data = istrstream_basic_data;

// private
bool getANL$( istrstream & is ) { return is.nlOnOff$; }
bool setANL$( istrstream & is, bool state ) { bool temp = is.nlOnOff$; is.nlOnOff$ = state; return temp;  }

// public
void ?{}( istrstream & is, char buf[] ) {
        is.buf$ = buf;
        is.cursor$ = 0;
        is.nlOnOff$ = false;
} // ?{}

void nlOn( istrstream & is ) { is.nlOnOff$ = true; }
void nlOff( istrstream & is ) { is.nlOnOff$ = false; }

int fmt( istrstream & is, const char format[], ... ) with(is) {
        va_list args;
        va_start( args, format );
        // THIS DOES NOT WORK BECAUSE VSSCANF RETURNS NUMBER OF VALUES READ VERSUS BUFFER POSITION SCANNED.
        int len = vsscanf( buf$ + cursor$, format, args );
        va_end( args );
        if ( len == EOF ) {
                abort | IO_MSG "invalid read";
        } // if
        // SKULLDUGGERY: This hack skips over characters read by vsscanf by moving to the next whitespace but it does not
        // handle C reads with wdi manipulators that leave the cursor at a non-whitespace character.
        for ( ; buf$[cursor$] != ' ' && buf$[cursor$] != '\t' && buf$[cursor$] != '\0'; cursor$ += 1 ) {
                //printf( "X \'%c\'\n", buf$[cursor$] );
        } // for
        if ( buf$[cursor$] != '\0' ) cursor$ += 1;      // advance to whitespace
        return len;
} // fmt

istrstream &ungetc( char c, istrstream & is ) {
        // if ( ungetc( c, (FILE *)(is.file$) ) == EOF ) {
        //      abort | IO_MSG "ungetc" | nl | strerror( errno );
        // } // if
        return is;
} // ungetc

bool eof( istrstream & is ) { return false; }
void clearerr( istrstream & ) {}                                                // no error flags to clear
void ends( istrstream & is ) {}

// Local Variables: //
// tab-width: 4 //
// End: //