token_stream.cpp

Go to the documentation of this file.

/*
 * token_stream.cpp
 *
 * Copyright (c) 2003 Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Implementation of various token stream objects.
 */

// includes --------------------------------------------------------------------
#include "token_stream.h"               // always include our own header first

#include "common/wave_ex.h"


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static bool
isBogus
(
IN char a
)
{
        return ('\r' == a);
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

void
getNextToken
(
IO std::istream& stream,
OUT std::string& token,
IN bool respect_quotes,
IN bool * eof
)
{
        ASSERT(!eof || !*eof, "passed-in eof flag is already true?");

        if (!stream.good()) {
                DPRINTF("bad stream?");
                WAVE_EX(wex);
                wex << "Bad input stream in getNextToken()";
        }
        token = "";
        char a;

        // skip comments
        while (true) {
                a = ' ';
                while (isspace(a) && !stream.eof()) {
                        stream.get(a);
                }

                if (stream.eof()) {
                        if (eof) {
                                *eof = true;
                                return;
                        }
                        WAVE_EX(wex);
                        wex << "Unexpected end of stream in getNextToken()";
                }

                // skip comments
                if ('#' != a)
                        break;  // not a comment, can exit

                while ('\n' != a && !stream.eof()) {
                        stream.get(a);
                }
                if (stream.eof()) {
                        if (eof) {
                                *eof = true;
                                return;
                        }
                        WAVE_EX(wex);
                        wex << "Unexpected end of stream in getNextToken()";
                }
        }

        // got a non-comment, non-space character.  Keep going
        bool in_quotes = false;
        if ('\"' == a ) {
                if (respect_quotes) {
                        in_quotes = true;
                }
        }
        while (true) {
                if (('\"' !=a || !in_quotes) && !isBogus(a)) {
                        token += a;
                }
                if (stream.eof()) {
                        if (in_quotes) {
                                DPRINTF("eof while reading quoted string");
                                WAVE_EX(wex);
                                wex << "Unexpected end of stream while reading quoted string.";
                        }
                        break;  // end of stream
                }

                // read next character
                stream.get(a);
                if (stream.eof()) {
                        break;          // end of input stream
                }
                if (in_quotes) {
                        if ('\"' == a)
                                break;  // end of quoted string
                        continue;       // keep reading
                }
                if (isspace(a))
                        break;          // end of token
        }

        // success!
        // DPRINTF("read token: '%s'", token.c_str());
}



void
expectToken
(
IO std::istream& stream,
IN const char * expect
)
{
        ASSERT(expect, "null expected token");

        std::string token;
        try {
                getNextToken(stream, token);
                if (expect != token) {
                        WAVE_EX(wex);
                        wex << "Read token '" << token << "' instead.";
                }
        } catch (std::exception& e) {
                WAVE_EX(wex);
                wex << "Expected token '" << expect << "', but encountered failure: ";
                wex << e.what();
        }
}



float
readFloat
(
IN std::istream& stream,
IO std::string& token
)
{
        ASSERT(stream.good(), "bad?");
        getNextToken(stream, token);
        return atof(token.c_str());
}



int
readInteger
(
IN std::istream& stream,
IO std::string& token
)
{
        ASSERT(stream.good(), "bad?");
        getNextToken(stream, token);
        return atoi(token.c_str());
}



long
readLong
(
IN std::istream& stream,
IO std::string& token
)
{
        ASSERT(stream.good(), "bad?");
        getNextToken(stream, token);
        return atol(token.c_str());
}



short
readShort
(
IN std::istream& stream,
IO std::string& token
)
{
        ASSERT(stream.good(), "bad?");
        getNextToken(stream, token);
        return (short) atoi(token.c_str());
}