ISstream.C

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     | Website:  https://openfoam.org
    \\  /    A nd           | Copyright (C) 2011-2024 OpenFOAM Foundation
     \\/     M anipulation  |
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.
 
    OpenFOAM is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    OpenFOAM 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 General Public License
    for more details.
 
    You should have received a copy of the GNU General Public License
    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
\*---------------------------------------------------------------------------*/
 
#include "ISstream.H"
#include "int.H"
#include "token.H"
#include "DynamicList.H"
#include <cctype>
 
// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 
char Foam::ISstream::nextValid()
{
    char c = 0;
 
    while (true)
    {
        // Get next non-whitespace character
        while (get(c) && isspace(c))
        {}
 
        // Return if stream is bad - ie, previous get() failed
        if (bad() || isspace(c))
        {
            break;
        }
 
        // Is this the start of a C/C++ comment?
        if (c == '/')
        {
            if (!get(c))
            {
                // Cannot get another character - return this one
                return '/';
            }
 
            if (c == '/')
            {
                // C++ style single-line comment - skip through past end-of-line
                while (get(c) && c != '\n')
                {}
            }
            else if (c == '*')
            {
                // Within a C-style comment
                while (true)
                {
                    // Search for end of C-style comment - '*/'
                    if (get(c) && c == '*')
                    {
                        if (get(c))
                        {
                            if (c == '/')
                            {
                                // Matched '*/'
                                break;
                            }
                            else if (c == '*')
                            {
                                // Check again
                                putback(c);
                            }
                        }
                    }
 
                    if (!good())
                    {
                        return 0;
                    }
                }
            }
            else
            {
                // The '/' did not start a C/C++ comment - return it
                putback(c);
                return '/';
            }
        }
        else
        {
            // A valid character - return it
            return c;
        }
    }
 
    return 0;
}
 
 
void Foam::ISstream::readWordToken(token& t)
{
    word* wPtr = new word;
 
    if (read(*wPtr).bad())
    {
        delete wPtr;
        t.setBad();
    }
    else if (token::compound::isCompound(*wPtr))
    {
        t = token::compound::New(*wPtr, *this).ptr();
        delete wPtr;
    }
    else
    {
        t = wPtr;
    }
}
 
 
Foam::Istream& Foam::ISstream::read(token& t)
{
    // Return the put back token if it exists
    if (Istream::getBack(t))
    {
        return *this;
    }
 
    // Assume that the streams supplied are in working order.
    // Lines are counted by '\n'
 
    // Get next 'valid character': i.e. proceed through any whitespace
    // and/or comments until a semantically valid character is found
 
    char c = nextValid();
 
    // Set the line number of this token to the current stream line number
    t.lineNumber() = lineNumber();
 
    // Return on error
    if (!c)
    {
        t.setBad();
        return *this;
    }
 
    // Analyse input starting with this character.
    switch (c)
    {
        // Check for punctuation first
 
        case token::END_STATEMENT :
        case token::BEGIN_LIST :
        case token::END_LIST :
        case token::BEGIN_SQR :
        case token::END_SQR :
        case token::BEGIN_BLOCK :
        case token::END_BLOCK :
        case token::COLON :
        case token::COMMA :
        case token::ASSIGN :
        case token::ADD :
        // NB: token::SUBTRACT handled later as the possible start of a Number
        case token::MULTIPLY :
        case token::DIVIDE :
        {
            t = token::punctuationToken(c);
            return *this;
        }
 
        // String: enclosed by double quotes.
        case token::BEGIN_STRING :
        {
            putback(c);
            string* sPtr = new string;
 
            if (read(*sPtr).bad())
            {
                delete sPtr;
                t.setBad();
            }
            else
            {
                t = sPtr;
            }
 
            return *this;
        }
 
        // Possible verbatim string or dictionary functionEntry
        case token::HASH :
        {
            char nextC;
            if (read(nextC).bad())
            {
                // Return hash as word
                t = token(word(c));
                return *this;
            }
            else if (nextC == token::BEGIN_BLOCK)
            {
                // Verbatim string
                verbatimString* vsPtr = new verbatimString;
 
                if (readVerbatim(*vsPtr).bad())
                {
                    delete vsPtr;
                    t.setBad();
                }
                else
                {
                    t = vsPtr;
                }
                return *this;
            }
            else
            {
                // Function name beginning with a #
                putback(nextC);
                putback(c);
 
                functionName* fnPtr = new functionName;
 
                if (read(*fnPtr).bad())
                {
                    delete fnPtr;
                    t.setBad();
                }
                else
                {
                    t = fnPtr;
                }
                return *this;
            }
        }
 
        case '$' :
        {
            // Look ahead
            char nextC;
            if (read(nextC).bad())
            {
                // Return $ as a word
                t = token(word(c));
                return *this;
            }
            else
            {
                putback(nextC);
                putback(c);
 
                variable* vPtr = new variable;
 
                if (readVariable(*vPtr).bad())
                {
                    delete vPtr;
                    t.setBad();
                }
                else
                {
                    t = vPtr;
                }
 
                return *this;
            }
        }
 
        // Number: integer or floating point
        //
        // ideally match the equivalent of this regular expression
        //
        //    /[-+]?([0-9]+\.?[0-9]*|\.[0-9]+)([Ee][-+]?[0-9]+)?/
        //
        case '-' :
        case '.' :
        case '0' : case '1' : case '2' : case '3' : case '4' :
        case '5' : case '6' : case '7' : case '8' : case '9' :
        {
            bool asLabel = (c != '.');
 
            buf_.clear();
            buf_.append(c);
 
            // Get everything that could resemble a number and let
            // readScalar determine the validity
            while
            (
                is_.get(c)
             && (
                    isdigit(c)
                 || c == '+'
                 || c == '-'
                 || c == '.'
                 || c == 'E'
                 || c == 'e'
                )
            )
            {
                if (asLabel)
                {
                    asLabel = isdigit(c);
                }
 
                buf_.append(c);
            }
 
            buf_.append('\0');
 
            setState(is_.rdstate());
            if (is_.bad())
            {
                t.setBad();
            }
            else
            {
                is_.putback(c);
 
                if (buf_.size() == 2 && buf_[0] == '-')
                {
                    // A single '-' is punctuation
                    t = token::punctuationToken(token::SUBTRACT);
                }
                else if (asLabel)
                {
                    label labelVal = 0;
                    uLabel uLabelVal = 0;
                    #if WM_LABEL_SIZE == 32
                    int64_t int64Val = 0;
                    uint64_t uint64Val = 0;
                    #endif
                    scalar scalarVal;
                    if (Foam::read(buf_.cdata(), labelVal))
                    {
                        t = labelVal;
                    }
                    else if (Foam::read(buf_.cdata(), uLabelVal))
                    {
                        t = uLabelVal;
                    }
                    #if WM_LABEL_SIZE == 32
                    else if (Foam::read(buf_.cdata(), int64Val))
                    {
                        t = int64Val;
                    }
                    else if (Foam::read(buf_.cdata(), uint64Val))
                    {
                        t = uint64Val;
                    }
                    #endif
                    else if (readScalar(buf_.cdata(), scalarVal))
                    {
                        t = scalarVal;
                    }
                    else
                    {
                        t.setBad();
                    }
                }
                else
                {
                    scalar scalarVal;
                    if (readScalar(buf_.cdata(), scalarVal))
                    {
                        t = scalarVal;
                    }
                    else
                    {
                        t.setBad();
                    }
                }
            }
 
            return *this;
        }
 
        // Should be a word (which can also be a single character)
        default:
        {
            putback(c);
            readWordToken(t);
 
            return *this;
        }
    }
}
 
 
Foam::Istream& Foam::ISstream::read(char& c)
{
    c = nextValid();
    return *this;
}
 
 
Foam::Istream& Foam::ISstream::read(word& str)
{
    buf_.clear();
 
    int listDepth = 0;
    char c;
 
    while (get(c) && word::valid(c))
    {
        if (c == token::BEGIN_LIST)
        {
            listDepth++;
        }
        else if (c == token::END_LIST)
        {
            if (listDepth)
            {
                listDepth--;
            }
            else
            {
                break;
            }
        }
 
        buf_.append(c);
    }
 
    if (bad())
    {
        // Truncate the string to the maximum error length
        buf_.data()[bufErrorLength] = buf_.last() = '\0';
 
        FatalIOErrorInFunction(*this)
            << "problem while reading word '" << buf_.cdata() << "...' after "
            << buf_.size() << " characters\n"
            << exit(FatalIOError);
 
        return *this;
    }
 
    if (buf_.empty())
    {
        FatalIOErrorInFunction(*this)
            << "invalid first character found : " << c
            << exit(FatalIOError);
    }
 
    // Append end string character
    buf_.append('\0');
    str = buf_.cdata();
    putback(c);
 
    return *this;
}
 
 
Foam::Istream& Foam::ISstream::read(string& str)
{
    buf_.clear();
 
    char c;
 
    if (!get(c))
    {
        FatalIOErrorInFunction(*this)
            << "cannot read start of string"
            << exit(FatalIOError);
 
        return *this;
    }
 
    // Note, we could also handle single-quoted strings here (if desired)
    if (c != token::BEGIN_STRING)
    {
        FatalIOErrorInFunction(*this)
            << "Incorrect start of string character found : " << c
            << exit(FatalIOError);
 
        return *this;
    }
 
    bool escaped = false;
 
    while (get(c))
    {
        if (c == token::END_STRING)
        {
            if (escaped)
            {
                escaped = false;
                buf_.remove(); // Overwrite backslash
            }
            else
            {
                // Append end string character
                buf_.append('\0');
                str = buf_.cdata();
                return *this;
            }
        }
        else if (c == token::NL)
        {
            if (escaped)
            {
                escaped = false;
                buf_.remove(); // Overwrite backslash
            }
            else
            {
                // Truncate the string to the maximum error length
                buf_.data()[bufErrorLength] = buf_.last() = '\0';
 
                FatalIOErrorInFunction(*this)
                    << "found '\\n' while reading string \""
                    << buf_.cdata() << "...\""
                    << exit(FatalIOError);
 
                return *this;
            }
        }
        else if (c == '\\')
        {
            escaped = !escaped;    // Toggle state (retains backslashes)
        }
        else
        {
            escaped = false;
        }
 
        buf_.append(c);
    }
 
    // Truncate the string to the maximum error length
    buf_.data()[bufErrorLength] = buf_.last() = '\0';
 
    FatalIOErrorInFunction(*this)
        << "problem while reading string \"" << buf_.cdata() << "...\""
        << exit(FatalIOError);
 
    return *this;
}
 
 
Foam::Istream& Foam::ISstream::readVariable(string& str)
{
    buf_.clear();
 
    char c;
 
    if (!get(c) || c != '$')
    {
        FatalIOErrorInFunction(*this)
            << "invalid first character found : " << c
            << exit(FatalIOError);
    }
 
    buf_.append(c);
 
    // Read next character to see if '{'
    if (get(c) && c == token::BEGIN_BLOCK)
    {
        // Read, counting brackets
        buf_.append(c);
 
        while
        (
            get(c)
         && (
                c == token::BEGIN_BLOCK
             || c == token::END_BLOCK
             || variable::valid(c)
            )
        )
        {
            buf_.append(c);
 
            int blockCount = 1;
 
            if (c == token::BEGIN_BLOCK)
            {
                blockCount++;
            }
            else if (c == token::END_BLOCK)
            {
                if (blockCount)
                {
                    blockCount--;
                }
                else
                {
                    break;
                }
            }
        }
    }
    else
    {
        buf_.append(c);
 
        int listDepth = 0;
 
        while (get(c) && variable::valid(c))
        {
            if (c == token::BEGIN_LIST)
            {
                listDepth++;
            }
            else if (c == token::END_LIST)
            {
                if (listDepth)
                {
                    listDepth--;
                }
                else
                {
                    break;
                }
            }
 
            buf_.append(c);
        }
    }
 
    if (bad())
    {
        // Truncate the string to the maximum error length
        buf_.data()[bufErrorLength] = buf_.last() = '\0';
 
        FatalIOErrorInFunction(*this)
            << "problem while reading string '" << buf_.cdata() << "...' after "
            << buf_.size() << " characters\n"
            << exit(FatalIOError);
 
        return *this;
    }
 
    if (buf_.empty())
    {
        FatalIOErrorInFunction(*this)
            << "invalid first character found : " << c
            << exit(FatalIOError);
    }
 
    // Append end string character
    buf_.append('\0');
    str = buf_.cdata();
 
    // Note: check if we exited due to '}' or just !variable::valid.
    if (c != token::END_BLOCK)
    {
        putback(c);
    }
 
    return *this;
}
 
 
Foam::Istream& Foam::ISstream::readVerbatim(verbatimString& str)
{
    buf_.clear();
 
    char c;
 
    while (get(c))
    {
        if (c == token::HASH)
        {
            char nextC;
            get(nextC);
            if (nextC == token::END_BLOCK)
            {
                buf_.append('\0');
                str = buf_.cdata();
                return *this;
            }
            else
            {
                putback(nextC);
            }
        }
 
        buf_.append(c);
    }
 
    // Truncate the string to the maximum error length
    buf_.data()[bufErrorLength] = buf_.last() = '\0';
 
    FatalIOErrorInFunction(*this)
        << "problem while reading string \"" << buf_.cdata() << "...\""
        << exit(FatalIOError);
 
    return *this;
}
 
 
Foam::ISstream& Foam::ISstream::getLine(string& s, const bool continuation)
{
    getline(is_, s);
    setState(is_.rdstate());
    lineNumber_++;
 
    if (continuation && s.size())
    {
        while (s.back() == '\\')
        {
            string contLine;
            getline(is_, contLine);
            setState(is_.rdstate());
            lineNumber_++;
            s.pop_back();
            s += contLine;
        }
    }
 
    return *this;
}
 
 
Foam::Istream& Foam::ISstream::readDelimited
(
    string& str,
    const char begin,
    const char end
)
{
    str.clear();
 
    int listDepth = 0;
    char c;
 
    while (get(c))
    {
        str += c;
 
        if (c == begin)
        {
            listDepth++;
        }
        else if (c == end)
        {
            listDepth--;
 
            if (listDepth <= 0)
            {
                break;
            }
        }
    }
 
    if (bad() || listDepth != 0)
    {
        FatalIOErrorInFunction(*this)
            << "    problem while reading delimited string \n"
            << str.c_str() << endl
            << exit(FatalIOError);
    }
 
    return *this;
}
 
 
Foam::Istream& Foam::ISstream::readList(string& str)
{
    return readDelimited(str, token::BEGIN_LIST, token::END_LIST);
}
 
 
Foam::Istream& Foam::ISstream::readBlock(string& str)
{
    return readDelimited(str, token::BEGIN_BLOCK, token::END_BLOCK);
}
 
 
Foam::Istream& Foam::ISstream::read(int32_t& val)
{
    is_ >> val;
    setState(is_.rdstate());
    return *this;
}
 
 
Foam::Istream& Foam::ISstream::read(int64_t& val)
{
    is_ >> val;
    setState(is_.rdstate());
    return *this;
}
 
 
Foam::Istream& Foam::ISstream::read(uint32_t& val)
{
    is_ >> val;
    setState(is_.rdstate());
    return *this;
}
 
 
Foam::Istream& Foam::ISstream::read(uint64_t& val)
{
    is_ >> val;
    setState(is_.rdstate());
    return *this;
}
 
 
Foam::Istream& Foam::ISstream::read(floatScalar& val)
{
    is_ >> val;
    setState(is_.rdstate());
    return *this;
}
 
 
Foam::Istream& Foam::ISstream::read(doubleScalar& val)
{
    is_ >> val;
    setState(is_.rdstate());
    return *this;
}
 
 
Foam::Istream& Foam::ISstream::read(longDoubleScalar& val)
{
    is_ >> val;
    setState(is_.rdstate());
    return *this;
}
 
 
Foam::Istream& Foam::ISstream::read(char* buf, std::streamsize count)
{
    if (format() != BINARY)
    {
        FatalIOErrorInFunction(*this)
            << "stream format not binary"
            << exit(FatalIOError);
    }
 
    readBegin("binaryBlock");
    is_.read(buf, count);
    readEnd("binaryBlock");
 
    setState(is_.rdstate());
 
    return *this;
}
 
 
Foam::Istream& Foam::ISstream::rewind()
{
    stdStream().rdbuf()->pubseekpos(0);
 
    return *this;
}
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 
std::ios_base::fmtflags Foam::ISstream::flags() const
{
    return is_.flags();
}
 
 
std::ios_base::fmtflags Foam::ISstream::flags(const ios_base::fmtflags f)
{
    return is_.flags(f);
}
 
 
// ************************************************************************* //