parser.cpp

Go to the documentation of this file.

/*
 * parser.cpp
 *
 * Copyright (C) 2007,2009   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 the primitive vector graphics parser.  See vgfx.h.
 */

// includes --------------------------------------------------------------------
#include "vgfx.h"               // always include our own header first!
#include "drawer.h"

#include <istream>
#include <sstream>

#include "common/wave_ex.h"
#include "objtree/objtree.h"    // property set
#include "perf/perf.h"
#include "util/parsing.h"
#include "util/token_stream.h"


// typedefs and constants ------------------------------------------------------

namespace vgfx {

static const eParseBehavior s_line_behavior = (eParseBehavior) (
    eParse_StripComments |
    eParse_StripBogus |
    eParse_RespectQuotes
    );

static const eParseBehavior s_token_behavior = eParse_RespectQuotes;



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

static bool
isMultilineType
(
IN const char * type
)
throw()
{
        ASSERT(type, "null");

        if (!strcmp("group", type) ||
            !strcmp("function", type))
                return true;
        return false;
}



static void
breakPath
(
IN const char * in_path,
OUT VecString& elements,
OUT VecString& relpath
)
{
        ASSERT(in_path, "null");

        elements.clear();

        std::string current;
        for (const char * p = in_path; *p; ++p) {
                if ('.' == *p) {
                        elements.push_back(current);
                        current = "";
                        continue;
                }

                current += *p;
        }
        elements.push_back(current);

        relpath.clear();
        for (int i = 1; i < (int) elements.size(); ++i) {
                relpath.push_back(elements[i]);
        }
}



void
processAdd
(
IN ObjectMap * map,
IN const char * action
)
{
        perf::Timer timer("processAdd");

        ASSERT(map, "null");
        ASSERT(action, "null");

        // DPRINTF("In processAdd()...");

        // convert to stream
        std::istringstream stream(action);
        std::string line, token;

        // keep reading lines
        while (!stream.eof()) {
                line = getNextLineFromStream(stream, s_line_behavior);

                // get the leading token
                const char * cursor =
                    getNextTokenFromString(line.c_str(), token, eParse_None);

                // empty?
                if ("" == token) {
                        continue;       // skip this line
                }

                // special case: group?
                if ("group" == token) {
                        getNextTokenFromString(cursor, token, eParse_None);
                        if ("{" != token) {
                                WAVE_EX(wex);
                                wex << "Expected an opening bracket after 'group' key.";
                                wex << "  Read '" << token << "' instead?";
                        }
                        smart_ptr<Primitive> g = parseGroup(stream, map);
                        ASSERT(g, "Failed to parse group?");
                        ASSERT(!strcmp("group", g->getType()),
                            "New object isn't a group?");
                        map->addObject(g);
                        // DPRINTF("Added a group...");

                        // skip to next input--don't fall into primitive parsing
                        continue;
                }

                // special case: function?
                if ("function" == token) {
                        getNextTokenFromString(cursor, token, eParse_None);
                        if ("{" != token) {
                                WAVE_EX(wex);
                                wex << "Expected an opening bracket after 'function' key.";
                                wex << "  Read '" << token << "' instead?";
                        }
                        smart_ptr<Primitive> fn = parseFunction(stream, map);
                        ASSERT(fn, "failed to parse function?");
                        ASSERT(!strcmp("function", fn->getType()),
                            "New object isn't a function?");
                        map->addObject(fn);
                        continue;
                }

                // construct dictionary
                dictionary_t dict;
                getDictionaryFromString(cursor, token.c_str(), dict);

                // create primitive
                try {
                        // DPRINTF("About to create an object of type '%s'", token);
                        smart_ptr<Primitive> p =
                            Primitive::create(token.c_str(), dict);
                        ASSERT(p, "failed to create object of type '%s'",
                            token.c_str());
                        // DPRINTF("  Adding to map...");
                        map->addObject(p);
                } catch (std::exception& e) {
                        // add some more messaging, and re-throw
                        WAVE_EX(wex);
                        wex << "Failed to create object of type '" << token;
                        wex << "': " << e.what();
                }
        }
}



static void
processSet
(
IN ObjectMap * map,
IN const char * action
)
{
        perf::Timer timer("processSet");

        ASSERT(map, "null");
        ASSERT(action, "null");

        // extract path
        std::string path;
        const char * cursor = getNextTokenFromString(action, path, eParse_None);
        VecString elements, relpath;
        breakPath(path.c_str(), elements, relpath);
        // DPRINTF("path = '%s'", path);
        // DPRINTF("path size = %d", elements.size());
        // DPRINTF("relative path size = %d", relpath.size());

        // extract dictionary
        dictionary_t data;
        getDictionaryFromString(cursor, "set", data);

        // get object
        Primitive * p = map->findObject(elements[0].c_str());
        if (!p) {
                WAVE_EX(wex);
                wex << "Set failed: object with id '" << elements[0] << "' ";
                wex << "does not exist";
        }

        // tell object the good news
        p->setContainerDictionary(relpath, data);
}



static void
processRemove
(
IN ObjectMap * map,
IN const char * action
)
{
        perf::Timer timer("processRemove");

        ASSERT(map, "null");
        ASSERT(action, "null");

        // get path
        std::string path;
        getNextTokenFromString(action, path, eParse_None);
        VecString elements, relpath;
        breakPath(path.c_str(), elements, relpath);

        if (1 == elements.size()) {
                // remove object!
                map->removeObject(elements[0].c_str());
                return;
        }

        // look up this object
        const char * id = elements[0].c_str();
        Primitive * p = map->findObject(id);
        if (!p) {
                WAVE_EX(wex);
                wex << "Error processing remove action: object does not exist:";
                wex << " '" << id << "'";
        }

        // ask object to delete container
        p->removeContainer(relpath);
}



static void
getActionString
(
IN const char * verb,
IO std::istream& stream,
OUT std::string& action
)
{
        // perf::Timer timer("getActionString");

        ASSERT(verb, "null action verb");

        action.clear();

        // extract first line no matter what
        std::string line = getNextLineFromStream(stream, s_line_behavior);
        action += line;

        // just one line, or multi?
        std::string token;
        getNextTokenFromString(line.c_str(), token, eParse_None);
        if (strcmp("add", verb) || !isMultilineType(token.c_str())) {
                return; // not adding multiline
        }

        // multi-line action!  keep parsing lines
        int depth = 1;
        while (depth > 0) {
                action += "\n";
                line = getNextLineFromStream(stream, s_line_behavior);
                action += line;

                // crap--won't this be destroyed by brackets in quotes???
                if (strstr(line.c_str(), "{"))
                        ++depth;
                if (strstr(line.c_str(), "}"))
                        --depth;
        }
}



static void
getUndoForAction
(
IN ObjectMap * map,
IN const char * verb,
IO const char * action,
OUT std::string& undo
)
{
        perf::Timer timer("getUndoForAction");

        ASSERT(map, "null map");
        ASSERT(verb, "null action verb");
        ASSERT(action, "null action");

        undo.clear();
        std::string line, path, token;

        if (!strcmp("add", verb)) {
                // adding an object.  Undo is a remove with that ID
                undo = "remove ";
                const char * cursor =
                    getNextTokenFromString(action, token, eParse_None);
                if (!isMultilineType(token.c_str())) {
                        // it's a single-line type (not a group)
                        dictionary_t data;
                        getDictionaryFromString(cursor, token.c_str(), data);
                        undo += getRequiredValue(data, "id");
                } else {
                        // it's a multi-line type (a group or function)
                        // walk through lines until we get the id
                        std::istringstream iss(action);
                        const char * cursor = NULL;
                        while ("id" != token) {
                                line =
                                    getNextLineFromStream(iss, s_line_behavior);
                                cursor = getNextTokenFromString(line.c_str(),
                                    token, eParse_None);
                        }
                        getNextTokenFromString(cursor, token, eParse_None);
                        undo += token;
                }
        } else if (!strcmp("remove", verb)) {
                // removing an object.  Undo is either an add or a set

                // get path
                getNextTokenFromString(action, path, eParse_None);
                VecString elements, relpath;
                breakPath(path.c_str(), elements, relpath);

                // get the ID, then the primitive
                Primitive * p = map->findObject(elements[0].c_str());
                if (!p) {
                        WAVE_EX(wex);
                        wex << "Asking to remove an object that does not ";
                        wex << "exist: '" << elements[0] << "'";
                }

                if (1 == elements.size()) {
                        // an entire object
                        // get persisted object
                        undo = "add ";
                        std::ostringstream persist;
                        p->persist(persist);
                        undo += persist.str();
                } else {
                        // a container
                        undo = "set ";
                        undo += path;
                        undo += " ";

                        // more
                        dictionary_t data;
                        p->getContainerDictionary(relpath, data);
                        for (dictionary_t::iterator i = data.begin();
                             i != data.end(); ++i) {
                                undo += i->first;
                                undo += " \"";
                                undo += i->second;
                                undo += "\" ";
                        }
                }
        } else if (!strcmp("set", verb)) {
                // changing an attribute value.
                //   Undo is a set with the old value, or a remove if this is a
                //   create

                // get path
                const char * cursor =
                    getNextTokenFromString(action, path, eParse_None);
                VecString elements, relpath;
                breakPath(path.c_str(), elements, relpath);
                if (elements.size() < 1) {
                        WAVE_EX(wex);
                        wex << "Invalid path: '" << path << "'";
                }

                // get the object
                const char * id = elements[0].c_str();
                Primitive * p = map->findObject(id);
                if (!p) {
                        WAVE_EX(wex);
                        wex << "Attempting to set attribute value for object ";
                        wex << "that does not exist, id='" << id << "'";
                }

                // does this path already exist?
                if (p->doesContainerExist(relpath)) {
                        // container exists!  Undo is a set with old values
                        undo = "set ";
                        undo += path;

                        // get all the old values for everything in the input
                        // dictionary
                        dictionary_t new_values;
                        getDictionaryFromString(cursor, "set", new_values);

                        dictionary_t old_values;
                        p->getContainerDictionary(relpath, old_values);

                        for (dictionary_t::iterator i = new_values.begin();
                             i != new_values.end(); ++i) {

                                const char * name = i->first.c_str();

                                dictionary_t::iterator d = old_values.find(name);
                                if (old_values.end() == d) {
                                        WAVE_EX(wex);
                                        wex << "Trying to set an attribute '";
                                        wex << name << "' that does not exist";
                                        wex << "in its container '" << path;
                                        wex << "'";
                                }

                                undo += " ";
                                undo += name;
                                undo += " \"";
                                undo += d->second;
                                undo += "\"";
                        }
                } else {
                        // container does not exist
                        if (!p->canCreateContainer(relpath)) {
                                WAVE_EX(wex);
                                wex << "Asking to set values in a container ";
                                wex << "that does not exist: '" << relpath[0];
                                wex << "'";
                        }

                        // container can be created!  Undo is a remove
                        undo = "remove ";
                        undo += path;
                }
        } else {
                WAVE_EX(wex);
                wex << "Invalid action verb: '" << verb << "', cannot undo.";
        }
}



static void
processAction
(
IN ObjectMap * map,
IN const char * verb,
IN const char * action
)
{
        perf::Timer timer("processAction");

        ASSERT(map, "null");
        ASSERT(verb, "null");
        ASSERT(action, "null");

        // what sort of verb is it?
        if (!strcmp("add", verb)) {
                // DPRINTF("Add request:\n%s\n--------", action);
                processAdd(map, action);
        } else if (!strcmp("remove", verb)) {
                // DPRINTF("Remove request (id = '%s')", action);
                processRemove(map, action);
        } else if (!strcmp("set", verb)) {
                // DPRINTF("Set request:\n%s\n-------", action);
                processSet(map, action);
        } else {
                WAVE_EX(wex);
                wex << "Cannot process this action verb: '" << verb << "'";
        }
}



static void
processRequestInternal
(
IN ObjectMap * map,
IN std::istream& stream,
IN bool single_transaction,
OUT VecString& undo_actions
)
{
        perf::Timer timer("processRequestInternal");
        // This function is used internally, called by processRequest()
        // That function handles opening/closing the undo request, and
        //   dealing with failures transactionally.  This function can
        //   throw at any time.  It should add undo actions for every
        //   action it successfully processes.
        ASSERT(map, "null");
        ASSERT(stream.good(), "bad request stream");

        undo_actions.clear();   // haven't done anything yet

        // verify the request begins with "request {"
        expectToken(stream, "request");
        expectToken(stream, "{");

        // keep parsing until we find the closing bracket
        std::string token;
        while (true) {
                getNextToken(stream, token);
                if (token == "}") {
                        break;          // end of request!
                }
                const char * verb = token.c_str();
                // DPRINTF("Parsing action of verb '%s'...", verb);

                // is this a valid action verb?
                if (token != "add" &&
                    token != "remove" &&
                    token != "set") {
                        WAVE_EX(wex);
                        wex << "Invalid action verb: '" << verb << "'";
                }

                // first, extract atomic action into a single string so we can
                //   parse it multiple times if necessary
                std::string action_str;
                getActionString(verb, stream, action_str);
                const char * action = action_str.c_str();
                // DPRINTF("Extracted action string:\n%s %s\n--------",
                //      verb, action);

                // get undo string for this action
                std::string undo;
                if (single_transaction) {
                        try {
                                getUndoForAction(map, verb, action, undo);
                        } catch (std::exception& e) {
                                WAVE_EX(wex);
                                wex << "Error calculating undo action for this";
                                wex << " action:\n" << verb << " " << action;
                                wex << "\nError: " << e.what();
                        }
                        // DPRINTF("Undo string:\n%s\n--------", undo.c_str());
                }

                // process action
                // DPRINTF("processing action '%s'", verb);
                try {
                        processAction(map, verb, action);
                } catch (std::exception& e) {
                        WAVE_EX(wex);
                        wex << "Error processing this action:\n";
                        wex << verb << " " << action << "\n";
                        wex << "Error: " << e.what();
                }

                // success!  Add undo to list
                if (single_transaction) {
                        undo_actions.push_back(undo);
                }
        }
}


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


bool
processRequest
(
IN ObjectMap * map,
IN std::istream& stream,
IN bool single_transaction,
OUT std::string& undo_request,
OUT std::string& diagnostic
)
{
        perf::Timer timer("processRequest");

        ASSERT(map, "null map in processRequest()");
        ASSERT(stream.good(), "bad stream in processRequest()");

        // clear input strings
        diagnostic.clear();
        undo_request.clear();

        VecString undo_actions; // list of undo actions

        // process the request
        bool success = false;
        try {
                processRequestInternal(map, stream, single_transaction,
                    undo_actions);
                success = true;
        } catch (std::exception& e) {
                diagnostic = e.what();
        } catch (...) {
                diagnostic = "Unknown exception!  Hard failure.";
                WAVE_EX(wex);
                wex << diagnostic;
        }

        // turn the undo actions into a request string
        if (single_transaction) {
                // walk through in reverse order
                undo_request = "request {\n";
                for (VecString::reverse_iterator iter = undo_actions.rbegin();
                     iter != undo_actions.rend(); ++iter) {
                        undo_request += *iter;
                        undo_request += "\n";
                }
                undo_request += "}";
        }
        // DPRINTF("Undo request:\n--------\n%s\n--------", undo_request.c_str());

        // success?
        if (success) {
                diagnostic = "Success.";
        } else if (single_transaction) {
                // failed, and in single transaction: attempt to roll back.
                //   (process the undo request we have)
                std::string local_undo = undo_request;
                undo_request = "";      // don't return anything to caller
                try {
                        VecString unused_undo;
                        std::istringstream undo_stream(local_undo);
                        processRequestInternal(map, undo_stream, false,
                            unused_undo);
                } catch (std::exception& e) {
                        diagnostic += "\nEncountered exception while trying to";
                        diagnostic += " roll back: ";
                        diagnostic += e.what();
                        diagnostic += "\nHard failure.";
                        WAVE_EX(wex);
                        wex << diagnostic;
                } catch (...) {
                        diagnostic += "\nUnknown exception while attempting to";
                        diagnostic += " roll back!\nHard failure.";
                        WAVE_EX(wex);
                        wex << diagnostic;
                }
        }

        // all done
        return success;
}



};      // vgfx namespace