scanner.cc

Go to the documentation of this file.

/*
 * Copyright (C) 2008 Kamil Dudka <xdudka00@stud.fit.vutbr.cz>
 *
 * This file is part of rob08
 *
 * rob08 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
 * any later version.
 *
 * rob08 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 rob08.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "config.h"
#include "scanner.h"

#include "robIO.h"

#ifndef BUILDING_DOX
#   include <assert.h>
#   include <boost/regex.hpp>
#   include <FlexLexer.h>
#   include <map>
#   include <sstream>
#endif

using namespace StreamDecorator;
using std::string;

class PrivateFlexLexer: public yyFlexLexer {
    public:
        PrivateFlexLexer(ICharReader *reader, string fileName):
#if DEBUG_STDIN_AS_TERM
            yyFlexLexer(&std::cin, &std::cerr),
#else
            yyFlexLexer(0, &std::cerr),
#endif
            reader_(reader),
            fileName_(fileName),
            hasError_(false)
        {
            yylineno = 0;
        }
        bool hasError() const {
            return hasError_;
        }
        EToken readNext() {
            EToken et = static_cast<EToken>
                (this->yylex());
            if (et)
                ++ yylineno;
            return et;
        }
        void postError(const char *msg) {
            this->LexerError(msg);
        }
    protected:
        virtual void LexerOutput(const char *buf, int size) {
            string msg(buf, size);
            this->LexerError(msg.c_str());
        }
        virtual void LexerError(const char *msg) {
            this->hasError_ = true;
            std::ostream &str = *(this->yyout);
            str << Error(E_ERROR, fileName_, msg, lineno(), "lexical error")
                << std::endl;
        }
#if not DEBUG_STDIN_AS_TERM
        virtual int LexerInput(char *buf, int nChars) {
            assert(0 < nChars);
            return reader_->getChar(*buf)
                ? 1:0;
        }
#endif
    private:
        ICharReader     *reader_;                       
        string          fileName_;                      
        bool            hasError_;                      
};

class FlexScanner: public IScanner {
    public:
        FlexScanner(ICharReader *reader, string fileName) {
            flex_ = new PrivateFlexLexer(reader, fileName);
        }
        virtual ~FlexScanner() {
            delete flex_;
        }
        virtual bool readNext(Token &token);
        virtual bool hasError() const {
            return flex_->hasError();
        }
    private:
        PrivateFlexLexer *flex_;                        
};

namespace {
    bool readHex(const string &str, unsigned &dest) {
        std::istringstream stream(str);
        stream >> std::hex >> dest;
        return stream;
    }
    bool readHexFromEnd(string &str, unsigned width, unsigned &dest) {
        // beware boost optimization
        string tmp(str);
        assert(0 < width);

        // build regex string
        const string hexByte("[0-9A-Fa-f]");
        string reStr("^(.*)(");
        for (unsigned i = 0; i < width; i++)
            reStr += hexByte;
        reStr += ")$";

        // match regex
        const boost::regex re(reStr);
        boost::smatch result;
        if (!boost::regex_match(str, result, re))
            return false;

        // read hex number
        if (!readHex(result[2], dest))
            return false;

        // cut string
        str = result[1];
        return true;
    }
    bool parsePmArgs(const string &str, Token::TArgVector &args) {
        string tmp(str);
        unsigned speed, distance, ratio;

        if (!readHexFromEnd(tmp, 2, ratio))
            return false;

        if (!readHexFromEnd(tmp, 4, distance))
            return false;

        if (!readHexFromEnd(tmp, 2, speed))
            return false;

        args.push_back(speed);
        args.push_back(distance);
        args.push_back(ratio);
        return true;
    }
}

std::ostream& operator<<(std::ostream &str, EToken type) {
    str << Color(C_YELLOW);
    switch (type) {
        case ET_NULL:                   str << "ET_NULL";                       break;
        case ET_GET_WHISKER_STATUS:     str << "ET_GET_WHISKER_STATUS";         break;
        case ET_GET_COMPASS_HEADING:    str << "ET_GET_COMPASS_HEADING";        break;
        case ET_GET_COMPASS_HEADING_EX: str << "ET_GET_COMPASS_HEADING_EX";     break;
        case ET_GET_TEMP:               str << "ET_GET_TEMP";                   break;
        case ET_GET_WATER:              str << "ET_GET_WATER";                  break;
        case ET_GET_PIR:                str << "ET_GET_PIR";                    break;
        case ET_GET_SONAR:              str << "ET_GET_SONAR";                  break;
        case ET_GET_TILT:               str << "ET_GET_TILT";                   break;
        case ET_GET_BATT_VOLTAGE:       str << "ET_GET_BATT_VOLTAGE";           break;
        case ET_GET_SW_VERSION:         str << "ET_GET_SW_VERSION";             break;
        case ET_GET_BUTTONS:            str << "ET_GET_BUTTONS";                break;
        case ET_GET_LIGHT_LEVEL:        str << "ET_GET_LIGHT_LEVEL";            break;
        case ET_GET_SOUND_LEVEL:        str << "ET_GET_SOUND_LEVEL";            break;
        case ET_GET_ENCODER_COUNTS:     str << "ET_GET_ENCODER_COUNTS";         break;
        case ET_CMD_PG:                 str << "ET_CMD_PG";                     break;
        case ET_CMD_PH:                 str << "ET_CMD_PH";                     break;
        case ET_CMD_PL:                 str << "ET_CMD_PL";                     break;
        case ET_CMD_PM:                 str << "ET_CMD_PM";                     break;
        case ET_CMD_PN:                 str << "ET_CMD_PN";                     break;
        case ET_CMD_PS:                 str << "ET_CMD_PS";                     break;
        case ET_CMD_PW:                 str << "ET_CMD_PW";                     break;
    }
    str << Color(C_NO_COLOR);
    return str;
}

std::ostream& operator<<(std::ostream &str, const Token &token) {
    // start with lineno:token_typ:
    str << Color(C_LIGHT_GREEN) << token.lineno << Color(C_NO_COLOR)
        << ":" << token.type;

    // append (...) in some cases
    switch (token.type) {
        case ET_NULL:
            break;

        case ET_CMD_PG:
        case ET_CMD_PH:
        case ET_CMD_PL:
        case ET_CMD_PN:
        case ET_CMD_PS:
        case ET_CMD_PW:
            if (token.args.size()!=1) {
                str << "[" << Color(C_LIGHT_RED) << "INVALID_ARGS" << Color(C_NO_COLOR) << "]";
                str << "[" << Color(C_LIGHT_RED) << token.text << Color(C_NO_COLOR) << "]";
                break;
            }
            str << "["
                << "code=" << Color(C_LIGHT_BLUE) << PrintHex(token.args[0], 2) << Color(C_NO_COLOR)
                << "]";
            break;

        case ET_CMD_PM:
            if (token.args.size()!=3) {
                str << "[" << Color(C_LIGHT_RED) << "INVALID_ARGS" << Color(C_NO_COLOR) << "]";
                str << "[" << Color(C_LIGHT_RED) << token.text << Color(C_NO_COLOR) << "]";
                break;
            }
            str << "["
                << "speed=" << Color(C_LIGHT_BLUE) << PrintHex(token.args[0], 2) << Color(C_NO_COLOR)
                << ", distance=" << Color(C_LIGHT_BLUE) << PrintHex(token.args[1], 4) << Color(C_NO_COLOR)
                << ", ratio=" << Color(C_LIGHT_BLUE) << PrintHex(token.args[2], 2) << Color(C_NO_COLOR)
                << "]";
            break;

        default:
            str << "[" << Color(C_LIGHT_RED) << token.text << Color(C_NO_COLOR) << "]";
            break;
    }
    str << Color(C_NO_COLOR);
    return str;
}

IScanner* ScannerFactory::createScanner(ICharReader *reader, std::string fileName) {
    return new FlexScanner(reader, fileName);
}

bool FlexScanner::readNext(Token &token) {
    EToken type;
readNext:
    if (!(type = flex_->readNext()))
        return false;

    // common part for all tokens
    token.type      = type;
    token.lineno    = flex_->lineno();
    token.text      = flex_->YYText();
    token.args.clear();

    switch (token.type) {
        case ET_CMD_PG:
        case ET_CMD_PH:
        case ET_CMD_PL:
        case ET_CMD_PN:
        case ET_CMD_PS:
        case ET_CMD_PW:
            {
                unsigned code;
                string tmp(token.text);
                if (!readHexFromEnd(tmp, 2, code)) {
                    if (token.type == ET_CMD_PG)
                        flex_->postError("invalid PG command");
                    else if (token.type == ET_CMD_PG)
                        flex_->postError("invalid PH command");
                    else if (token.type == ET_CMD_PL)
                        flex_->postError("invalid PL command");
                    else if (token.type == ET_CMD_PN)
                        flex_->postError("invalid PN command");
                    else if (token.type == ET_CMD_PS)
                        flex_->postError("invalid PS command");
                    else
                        flex_->postError("invalid PW command");
                    goto readNext;
                }
                token.args.push_back(code);
            }
            break;

        case ET_CMD_PM:
            if (!parsePmArgs(token.text, token.args)) {
                flex_->postError("invalid PM command");
                goto readNext;
            }
            break;

        default:
            break;
    }

#if DEBUG_TERM_INPUT
    std::cerr << Color(C_LIGHT_BLUE) << "TERM" << Color(C_NO_COLOR) << " --> "
        << token << std::endl;
#endif

    return true;
}

---