---

mstream.cc

/***************************************************************************
 *   This file is part of the MagiC++ library.                             *
 *                                                                         *
 *   Copyright (C) 1998-2001 Marko Grönroos <magi@iki.fi>                  *
 *                                                                         *
 ***************************************************************************
 *                                                                         *
 *  This library is free software; you can redistribute it and/or          *
 *  modify it under the terms of the GNU Library General Public            *
 *  License as published by the Free Software Foundation; either           *
 *  version 2 of the License, or (at your option) any later version.       *
 *                                                                         *
 *  This library is distributed in the hope that it will be useful,        *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU      *
 *  Library General Public License for more details.                       *
 *                                                                         *
 *  You should have received a copy of the GNU Library General Public      *
 *  License along with this library; see the file COPYING.LIB.  If         *
 *  not, write to the Free Software Foundation, Inc., 59 Temple Place      *
 *  - Suite 330, Boston, MA 02111-1307, USA.                               *
 *                                                                         *
 ***************************************************************************/

#include "magic/mobject.h"
#include "magic/mstream.h"
#include "magic/mpararr.h"

#ifdef SunOS
#include <sys/varargs.h>
#else
#include <stdarg.h>
#endif


// Standard output
OStream sout (stdout);
OStream serr (stderr);

//                                                                           //
//                       ----                                                //
//                      (      |       ___   ___                             //
//                       ---  -+- |/\ /   )  ___| |/|/|                      //
//                          )  |  |   |---  (   | | | |                      //
//                      ___/    \ |    \__   \__| | | |                      //
//                                                                           //

void Stream::close () {
    if (stream)
        fclose (stream);
}

//                                                                           //
//                    ___   ----                                             //
//                   |   | (      |       ___   ___                          //
//                   |   |  ---  -+- |/\ /   )  ___| |/|/|                   //
//                   |   |     )  |  |   |---  (   | | | |                   //
//                   `___´ ___/    \ |    \__   \__| | | |                   //
//                                                                           //

OStream::OStream (FILE* strm=stdout) : Stream (strm) {
    aflush=0;
    mUserFlags = 0;
}

OStream::OStream (OStream& o) : Stream (o.stream) {
    aflush = o.aflush;
    mUserFlags = 0;
}


OStream& OStream::print (const char c) {
    if (!stream)
        return *this;

    ::fputc (c, stream);
    
    if (aflush)
        fflush (stream);

    return *this;
}

OStream& OStream::print (const char* str) {
    if (!stream)
        return *this;

    ::fputs (str, stream);

    if (aflush)
        fflush (stream);
    return *this;
}

OStream& OStream::printf (const char* sformat, ...) {
    if (!stream)
        return *this;

    va_list args;
    va_start (args, sformat);
    vfprintf (stream, sformat, args);
    va_end (args);

    if (aflush)
        fflush (stream);
    return *this;
}

OStream& OStream::operator<< (const char* str) {
    return print (str);
}

OStream& OStream::operator<< (int i) {
    return operator<< ((long) i);
}

OStream& OStream::operator<< (long i) {
    printf ("%d", i);
    return *this;
}


void OStream::operator= (const OStream& other) {
    stream = other.stream;
    aflush = other.aflush;
}

void OStream::setFlag (int flag, bool value) {
    ASSERT (flag>=0 && flag<32);
    mUserFlags &= ~(long(1)<<flag);
    mUserFlags |= (long(value)<<flag);
}

bool OStream::flag (int flag) const{
    ASSERT (flag>=0 && flag<32);
    return mUserFlags & (long(1)<<flag);
}



//                                                                           //
//                    ---  ----                                              //
//                     |  (      |       ___   ___                           //
//                     |   ---  -+- |/\ /   )  ___| |/|/|                    //
//                     |      )  |  |   |---  (   | | | |                    //
//                    _|_ ___/    \ |    \__   \__| | | |                    //
//                                                                           //

// KLUDGE
//#define IStream DumpContext

bool IStream::openload (const char* filename) {
    stream = fopen (filename, "rb");
    return stream;
}

IStream& IStream::operator>> (int& i) {
    long i2=i;
    operator>> (i2);
    i=i2;
    return *this;
}

IStream& IStream::operator>>    (long& i)           {
    if (stream)
        ASSERT (fread ((char*) &i, sizeof(i), 1, stream) == 1);
    return *this;
}

IStream& IStream::operator>>    (char& i)           {
    if (stream)
        ASSERT (fread ((char*) &i, sizeof(i), 1, stream) == 1);
    return *this;
}

IStream& IStream::operator>> (float& i) {
    double i2=i;
    operator>> (i2);
    i=i2;
    return *this;
}

IStream& IStream::operator>>    (double& i)         {
    if (stream)
        ASSERT (fread ((char*) &i, sizeof(i), 1, stream) == 1);
    return *this;
}

IStream& IStream::read      (char* p, int n)    {
    if (stream) {
        int bytesread = fread (p, 1, n, stream);
        ASSERTWITH (bytesread == n,
                    format ("%d bytes read instead of %d that were asked",
                            bytesread, n));
    }
    return *this;
}

IStream& operator<< (IStream& out, const char* str) {
    //out.name (str);
    //return out;
    return out;
}



//                                                                           //
//         ___                     ___                                       //
//         |  \               --  /   \        _    |   ___       |          //
//         |   | |   | |/|/| |  ) |      __  |/ \  -+- /   ) \ / -+-         //
//         |   | |   | | | | |--  |     /  \ |   |  |  |---   X   |          //
//         |__/   \__! | | | |    \___/ \__/ |   |   \  \__  / \   \         //
//                                                                           //

DumpContext::DumpContext (FILE* strm=stdout) : OStream (strm) {
    names = false;
    classnames = false;
    depth=0;
    prevdepth=-1;

    mode = DUMP_TEXT;
    attribs = NULL;
}

DumpContext::DumpContext (OStream& o) : OStream (o) {
    names = false;
    classnames = false;
    depth=0;
    prevdepth=-1;

    mode = DUMP_TEXT;
    attribs = NULL;
}

DumpContext::~DumpContext () {
    delete attribs;
}

DumpContext& DumpContext::printf (const char* sformat, ...) {
    if (!stream)
        return *this;

    va_list args;
    va_start (args, sformat);
    vfprintf (stream, sformat, args);
    va_end (args);

    if (aflush)
        fflush (stream);

    return *this;
}

DumpContext& DumpContext::printName (){ 
    if (mode&DUMP_TEXT && !nextname.isEmpty()) {
        print (nextname);
        print ("=");
        nextname=""; // NULL originally, but causes ambiquity with some compilers
    }
    return *this;
}

void DumpContext::printIndent () {
    if ((mode & DUMP_TEXT) && false)
        for (int j=0; j<depth; j++)
            print ("    ");
}

void DumpContext::printComma () {
    if (depth<=prevdepth)
        print (", ");
    prevdepth = depth;
}

#define CHECKRECORD(rtype,var) \
    if (mode&DUMP_RECORD) {\
        if (nextname.isEmpty())\
            nextname = "?";\
        attribs->add (new String (strformat ("%s %s", #rtype, (CONSTR)nextname)));\
        return *this;\
    }

DumpContext& DumpContext::operator<< (int i) {
    CHECKRECORD (int, i);

    operator<< ((long) i);
    return *this;
}

DumpContext& DumpContext::operator<< (long i) {
    CHECKRECORD (long, int (i));

    if (mode&DUMP_TEXT) {
        printComma ();
        printName ();
        printf ("%d", i);
    }// else
    //  out->write ((char*) &i, sizeof(i));
    return *this;
}

DumpContext& DumpContext::operator<<    (char i)                {
    CHECKRECORD (char, i);
    //if (out)
        // out->write ((char*) &i, sizeof(i));
    return *this;
}

DumpContext& DumpContext::operator<< (float i) {
    CHECKRECORD (float, i);
    operator<< ((double) i);
    return *this;
}

DumpContext& DumpContext::operator<<    (double i)              {
    CHECKRECORD (double, float(i));
    if (mode&DUMP_TEXT) {
        printComma ();
        printName ();
        printf ("%f", i);
    } // else
        // out->write ((char*) &i, sizeof(i));
    return *this;
}

DumpContext& DumpContext::operator<< (CONSTR str) {
    if (mode&DUMP_TEXT) {
        printComma ();
        printName ();
        print (str);
    }
    return *this;
}

DumpContext& DumpContext::write     (const char* p, int n)  {
    CHECKRECORD (char*, p);
    if (mode&DUMP_TEXT) {
        printIndent ();
        printComma ();
        printName ();
        String str, str2 (p, n);
        if (str2.isNull())
            print ("NULL");
        else {
            // str.hexcode (str2);
            printf ("\x22%s\x22", (CONSTR) str2);
        }
    } // else
    // write ((char*) &i, sizeof(i));
    return *this;
}

---