BESTokenizer.cc

// BESTokenizer.cc
 
// This file is part of bes, A C++ back-end server implementation framework
// for the OPeNDAP Data Access Protocol.
 
// Copyright (c) 2004-2009 University Corporation for Atmospheric Research
// Author: Patrick West <pwest@ucar.edu> and Jose Garcia <jgarcia@ucar.edu>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
// You can contact University Corporation for Atmospheric Research at
// 3080 Center Green Drive, Boulder, CO 80301
 
// (c) COPYRIGHT University Corporation for Atmospheric Research 2004-2005
// Please read the full copyright statement in the file COPYRIGHT_UCAR.
//
// Authors:
//      pwest       Patrick West <pwest@ucar.edu>
//      jgarcia     Jose Garcia <jgarcia@ucar.edu>
 
#include <cstring>
#include <iostream>
 
using std::cout;
using std::endl;
using std::ostream;
using std::string;
 
#include "BESTokenizer.h"
#include "BESSyntaxUserError.h"
 
BESTokenizer::BESTokenizer() :
    _counter(-1), _number_tokens(0)
{
}
 
BESTokenizer::~BESTokenizer()
{
}

void BESTokenizer::parse_error(const string &s)
{
    string error = "Parse error.";
    string where = "";
    if (_counter >= 0) {
        for (int w = 0; w < _counter + 1; w++)
            where += tokens[w] + " ";
        where += "<----HERE IS THE ERROR";
        error += "\n" + where;
    }
    if (s != "") error += "\n" + s;
    throw BESSyntaxUserError(error, __FILE__, __LINE__);
}

string &
BESTokenizer::get_first_token()
{
    _counter = 0;
    return tokens[_counter];
}

string &
BESTokenizer::get_current_token()
{
    if (_counter < 0 || _counter > (int)_number_tokens - 1) {
        parse_error("incomplete expression!");
    }
 
    return tokens[_counter];
}

string &
BESTokenizer::get_next_token()
{
    if (_counter == -1) {
        parse_error("incomplete expression!");
    }
 
    if (_counter >= (int) (_number_tokens - 1)) {
        parse_error("incomplete expression!");
    }
 
    return tokens[++_counter];
}

void BESTokenizer::tokenize(const char *p)
{
    size_t len = strlen(p);
    string s = "";
    bool passing_raw = false;
    bool escaped = false;
 
    for (unsigned int j = 0; j < len; j++) {
 
        if (!escaped && p[j] == '\"') {
 
            if (s != "") {
                if (passing_raw) {
                    s += "\"";
                    tokens.push_back(s);
                    s = "";
                }
                else {
                    tokens.push_back(s);
                    s = "\"";
                }
            }
            else {
                s += "\"";
            }
            passing_raw = !passing_raw;
 
        }
        else if (passing_raw) {
 
            if (!escaped && p[j] == '\\') {
                escaped = true;
            }
            else {
                s += p[j];
 
                if (escaped) escaped = false;
            }
 
        }
        else {
            if ((p[j] == ' ') || (p[j] == '\n') || (p[j] == 0x0D) || (p[j] == 0x0A)) {
                if (s != "") {
                    tokens.push_back(s);
                    s = "";
                }
            }
            else if ((p[j] == ',') || (p[j] == ';')) {
                if (s != "") {
                    tokens.push_back(s);
                    s = "";
                }
                switch (p[j]) {
                case ',':
                    tokens.push_back(",");
                    break;
                case ';':
                    tokens.push_back(";");
                    break;
                }
            }
            else
                s += p[j];
        }
    }
 
    if (s != "") tokens.push_back(s);
    _number_tokens = tokens.size();
    if (passing_raw) parse_error("Unclose quote found.(\")");
    if (_number_tokens < 1) parse_error("Unknown command: '" + (string) p + (string) "'");
    if (tokens[_number_tokens - 1] != ";") parse_error("The request must be terminated by a semicolon (;)");
}

string BESTokenizer::parse_container_name(const string &s, unsigned int &type)
{
    string::size_type where = s.rfind(".constraint=", s.size());
    if (where == string::npos) {
        where = s.rfind(".attributes=", s.size());
        if (where == string::npos) {
            parse_error("Expected property declaration.");
        }
        else {
            type = 2;
        }
    }
    else {
        type = 1;
    }
    string valid = s.substr(where, s.size());
    if ((valid != ".constraint=") && (valid != ".attributes=")) {
        string err = (string) "Invalid container property " + valid + " for container " + s.substr(0, where)
            + ". constraint expressions and attribute lists " + "must be wrapped in quotes";
        parse_error(err);
    }
    return s.substr(0, where);
}

string BESTokenizer::remove_quotes(const string &s)
{
    if ((s[0] != '"') || (s[s.size() - 1] != '"')) {
        parse_error("item " + s + " must be enclosed by quotes");
    }
    return s.substr(1, s.size() - 2);
}

void BESTokenizer::dump_tokens()
{
    tokens_citerator i = tokens.begin();
    tokens_citerator ie = tokens.end();
    for (; i != ie; i++) {
        cout << "\"" << (*i) << "\"" << endl;
    }
}

void BESTokenizer::dump(ostream &strm) const
{
    strm << BESIndent::LMarg << "BESTokenizer::dump - (" << (void *) this << ")" << endl;
    BESIndent::Indent();
    tokens_citerator i = tokens.begin();
    tokens_citerator ie = tokens.end();
    for (; i != ie; i++) {
        strm << BESIndent::LMarg << "\"" << (*i) << "\"" << endl;
    }
    BESIndent::UnIndent();
}