---

mtextstream.cc

Go to the documentation of this file.

#include "magic/mtextstream.h"

#include <ctype.h>
#include <math.h>
#include <stdarg.h>

BEGIN_NAMESPACE (MagiC);

TextOStream sout (stdout); // Standard output
TextOStream serr (stderr); // Standard error output
TextIStream stin (stdin);  // Standard input


/*****************************************************************************/
inline void checkDevice (const IODevice* dev)
{
    if (!dev)
        throw stream_failure (i18n("Operated stream not associated with a device."));
}

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

void TextStream::copy (const TextStream& other)
{
    mFieldWidth = other.mFieldWidth;
    mFillChar   = other.mFillChar;
    mPrecision  = other.mPrecision;
    mBase       = other.mBase;
}


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

/*****************************************************************************/
TextOStream::TextOStream (FILE* strm    )
        : OStream (strm)
{
}

/*****************************************************************************/
TextOStream::TextOStream (TextOStream& orig) 
        : OStream (orig)
{
}

/*****************************************************************************/
TextOStream::TextOStream (String& buffer, 
                          int mode)
        : OStream (buffer, mode)
{
}

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

    va_list args;
    va_start (args, sformat);

    // Sprint to a buffer first.
    String buffer = vstrformat (sformat, args);

    // Write the buffer to the device
    mpDevice->writeBlock (buffer);
    
    va_end (args);
    
    if (isAutoFlush())
      mpDevice->flush();

   return *this;
}

void TextOStream::copy (const TextOStream& other)
{
    OStream::copy (other);
    TextStream::copy (other);
}

TextOStream& TextOStream::operator<< (const char* str)
{
    if (mpDevice)
        mpDevice->writeBlock (str, strlen (str));
    return *this;
}

TextOStream& TextOStream::operator<< (const char c)
{
    if (mpDevice)
        mpDevice->putch (c);
    return *this;
}

TextOStream& TextOStream::operator<< (int x)
{
    if (mpDevice)
        mpDevice->writeBlock (String(x));
    return *this;
}

TextOStream& TextOStream::operator<< (long x)
{
    if (mpDevice)
        mpDevice->writeBlock (String(x));
    return *this;
}

TextOStream& TextOStream::operator<< (float x)
{
    if (mpDevice)
        mpDevice->writeBlock (String(x));
    return *this;
}

TextOStream& TextOStream::operator<< (double x)
{
    if (mpDevice)
        mpDevice->writeBlock (String(x));
    return *this;
}

TextOStream& TextOStream::operator<< (const String& str)
{
    if (mpDevice)
        mpDevice->writeBlock (str);
    return *this;
}

uint TextOStream::writeRawBytes (const char* str, uint length)
{
    if (mpDevice)
        return mpDevice->writeBlock (str, length);

    return 0;
}



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

TextIStream& TextIStream::operator>> (char& rCh)
{
    checkDevice (mpDevice);

    // This is simple, just read the character
    rCh = mpDevice->getch ();

    return *this;
}

TextIStream& TextIStream::operator>> (long& rValue)
{
    /* This function is exactly same as above. Any way to remove the redundancy? */
       
    checkDevice (mpDevice);

    //  We need to read the value character by character.
    rValue = 0;
    int sign = 1; // Positive
    while (! mpDevice->atEnd()) {
        char ch = mpDevice->getch ();

        if (isdigit(ch))
            rValue = rValue*10 + long (ch - '0'); // The character is a digit; add it to the value.
        else if (ch == '-')
            sign = -1;
        else if (ch == '+')
            sign = 1;
        else {
            // It wasn't a digit, so we didn't want to read it.
            mpDevice->ungetch (ch);
            break;
        }
    }

    rValue *= sign;
    
    return *this;
}

TextIStream& TextIStream::operator>> (int& rValue)
{

    // Read the value as double-precision
    long lvalue = 0;
    *this >> lvalue;

    // Convert it
    rValue = int (lvalue);
    
    return *this;
}

TextIStream& TextIStream::operator>> (double& rValue)
{
    checkDevice (mpDevice);

    // We parse the value with a state machine
    enum   states {NONE, SIGNFOUND, DOTFOUND, EXPFOUND, EXPSIGNFOUND, END} state = NONE;
    char   ch      = 0;     // Character read from device
    int    sign    = 1;     // Positive
    double fract   = 1.0;   // Multiplier for past-dot digits
    int    exp     = 0;     // Exponent
    int    expsign = 1;     // Sign of the exponent

    // Skip whitespace
    ch = mpDevice->getch ();
    while (isspace (ch))
        ch = mpDevice->getch ();
    
    //  Read the value character by character, until value ends, or EOF.
    rValue = 0;
    while ((!mpDevice->atEnd()) && (state != END)) {
        // If the character is a digit, add it to the value
        switch (state) {
          case NONE:
              // Check for sign
              if (state == NONE && ch == '-') {
                  sign = -1;
                  break;
              } else if (state == NONE && ch == '+') {
                  sign = 1;
                  break;
              }
              state = SIGNFOUND; // It wasn't sign, so it might be a number.
              // Fall through:
              
          case SIGNFOUND:
              if (isdigit(ch)) {
                  rValue = rValue*10.0 + float (ch - '0');
              } else if (ch == '.')
                  state = DOTFOUND;
              else if (ch == 'e' || ch == 'E')
                  state = EXPFOUND;
              else
                  state = END;
              break;
              
          case DOTFOUND:
              if (isdigit (ch)) {
                  // Handle post-comma digit
                  fract /= 10.0;
                  rValue = rValue + double (ch - '0')*fract;
              } else if (ch == 'e' || ch == 'E')
                  state = EXPFOUND;
              else
                  state = END;
              break;
              
          case EXPFOUND:
              // Check for sign
              if (ch == '-') {
                  expsign = -1;
                  break;
              } else if (ch == '+') {
                  expsign = 1;
                  break;
              }
              state = EXPSIGNFOUND; // It wasn't sign, so it might be a number.
              // Fall through:
              
          case EXPSIGNFOUND:
              if (isdigit(ch))
                  exp = exp*10 + int (ch - '0');
              else
                  state = END;
              break;

          case END:
              break;
        };

        // Read the next character
        ch = mpDevice->getch ();
    }

    if (state == END) {
        // It wasn't a digit, so we didn't want to read it.
        mpDevice->ungetch (ch);
    }
    
    // Correct the sign
    rValue *= sign;

    // Apply exponent
    if (exp != 0)
        rValue *= pow (10, double (exp*expsign));
    
    return *this;
}

TextIStream& TextIStream::operator>> (float& rValue)
{
    // Read the value as double-precision
    double dvalue = 0.0;
    *this >> dvalue;

    // Convert it
    rValue = float (dvalue);
    
    return *this;
}

TextIStream& TextIStream::operator>> (String& str)
{
    // Use the object's operation.
    //str.String::operator<< (*this);
    str.operator<< (*this);
    
    return *this;
}

/*****************************************************************************/
TextIStream& TextIStream::read (char* p, 
                                int n    )
{
    String buffer;
    buffer << *this;

    if ((buffer.length() > 0) && (n > 0))
        strncpy (p,
                 (CONSTR) buffer,
                 (uint(n) > buffer.length())? buffer.length() : n);
    
    return *this;
}

/*****************************************************************************/
uint TextIStream::readRawBytes (char* data,
                               uint maxlen)
{
    if (mpDevice)
        return mpDevice->readBlock (data, maxlen);
    else
        return 0;
}

int TextIStream::readLine (String& linebuf)
{
    if (!mpDevice || !mpDevice->isOpen() || mpDevice->atEnd())
        return 0;

    linebuf.empty ();

    // Read line in chunks
    char buffer [1024+1];
    int bytesRead = 0;
    int totalRead = 0;
    while ((bytesRead = mpDevice->readLine (buffer, 1024))) {
        linebuf.append (buffer);
        totalRead += bytesRead;

        // If bytes read was 1024 bytes, there may be more.
        // WARNING: Should we check if the last byte is newline???
        if (bytesRead < 1024)
            break;
    }

    return totalRead;
}

END_NAMESPACE;

---