HeyParser.cc

Go to the documentation of this file.

/*
 * HeyParser.cc
 *
 * Copyright (c) 2003 The University of Utah and the Flux Group.
 * All rights reserved.
 *
 * This file is licensed under the terms of the GNU Public License.  
 * See the file "license.terms" for restrictions on redistribution 
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

/**
 * @file HeyParser.cc
 *
 * Implementation file for the HeyParser class.
 */

#include "config.h"

#include <string.h>
#include <assert_pp.h>

#include "HeyParser.hh"

HeyPropertyInfo HeyPropertyInfo::HPI_NULL(NULL, 0, NULL, NULL);

const char *HeyParser::hp_what_strings[WHAT_MAX] = {
    "shutdown",
    "list",
    "get",
    "set",
    "create",
    "delete",
    "execute",
    "getsuites",
};

HeyParser::HeyParser(int argc, const char *argv[])
    throw (HeyParserException)
{
    require(argc > 0);
    require(argv != NULL);

    /* Need atleast three args (program name, server name, what value) */
    if( argc < 3 )
    {
        throw HeyParserException("Missing required arguments.");
    }

    /* Store the arguments and then */
    this->hp_ArgCount = argc;
    this->hp_ArgValue = argv;
    this->hp_ArgIndex = 3;

    /* ... verify the server name, */
    if( strlen(argv[1]) == 0 )
    {
        throw HeyParserException("Empty server name");
    }

    /* ... figure out the 'what' value, and */
    if( (strcasecmp(argv[2], "shutdown") == 0) ||
        (strcasecmp(argv[2], "exit") == 0) ||
        (strcasecmp(argv[2], "quit") == 0) )
    {
        this->hp_What = SHUTDOWN;
    }
    else if( strcasecmp(argv[2], "list") == 0 )
    {
        this->hp_What = LIST_PROPERTIES;
    }
    else if( strcasecmp(argv[2], "get") == 0 )
    {
        this->hp_What = GET_PROPERTY;
    }
    else if( strcasecmp(argv[2], "set") == 0 )
    {
        this->hp_What = SET_PROPERTY;
    }
    else if( strcasecmp(argv[2], "create") == 0 )
    {
        this->hp_What = CREATE_PROPERTY;
    }
    else if( strcasecmp(argv[2], "delete") == 0 )
    {
        this->hp_What = DELETE_PROPERTY;
    }
    else if( strcasecmp(argv[2], "execute") == 0 )
    {
        this->hp_What = EXECUTE_PROPERTY;
    }
    else if( strcasecmp(argv[2], "getsuites") == 0 )
    {
        this->hp_What = GET_SUITES;
    }
    else
    {
        throw HeyParserException("Unknown verb value.");
    }

    /* ... push any property lists, */
    while( (this->hp_ArgIndex < this->hp_ArgCount) &&
           (strcasecmp(this->hp_ArgValue[this->hp_ArgIndex], "to") != 0) &&
           (strcasecmp(this->hp_ArgValue[this->hp_ArgIndex], "with") != 0) )
    {
        struct Pair pair;

        this->nextProperty(pair.p_Name, pair.p_Value);
        this->hp_PropertyStack.push(pair);
    }

    /* ... pickup the 'to' value, if this is a set, */
    if( this->hp_What == SET_PROPERTY )
    {
        try
        {
            const char *arg;

            arg = this->consumeArg();
            if( strcasecmp(arg, "to") != 0 )
            {
                throw HeyParserException("Expecting 'to' keyword, found", arg);
            }
        }
        catch(const HeyParserException &e)
        {
            throw HeyParserException("Missing 'to' keyword.");
        }
        
        try
        {
            this->hp_ToValue = this->consumeArg();
        }
        catch(const HeyParserException &e)
        {
            throw HeyParserException("Missing 'to' value.");
        }
    }

    /* ... and finally, eliminate the 'with' keyword. */
    if( (this->hp_ArgIndex < this->hp_ArgCount) &&
        (strcasecmp(this->hp_ArgValue[this->hp_ArgIndex], "with") == 0) )
    {
        int lpc, with_count;
        
        this->hp_ArgIndex += 1;
        if( this->hp_ArgIndex == this->hp_ArgCount )
        {
            throw HeyParserException("No arguments after 'with'");
        }
        for( lpc = this->hp_ArgIndex, with_count = 0;
             lpc < this->hp_ArgCount;
             lpc++ )
        {
            with_count += 1;
            if( strchr(this->hp_ArgValue[lpc], '=') )
            {
                with_count += 1;
            }
        }
        if( (with_count % 2) == 1 )
        {
            throw HeyParserException("Odd number of 'with' arguments");
        }
    }

    ensure(this->hp_What >= 0);
    ensure(this->hp_What < WHAT_MAX);
    ensure(this->hp_ArgValue != NULL);
    ensure((this->hp_What != SET_PROPERTY) || (this->hp_ToValue != NULL));
    ensure(this->hp_ArgIndex > 0);
}

HeyParser::~HeyParser(void)
{
    this->hp_ArgCount = 0;
    this->hp_ArgValue = NULL;
    this->hp_ToValue = NULL;
    this->hp_ArgIndex = -1;
}

const char *HeyParser::consumeArg(void)
    throw (HeyParserException)
{
    const char *retval;

    if( this->hp_ArgIndex >= this->hp_ArgCount )
    {
        throw HeyParserException("No more arguments");
    }
    
    retval = this->hp_ArgValue[this->hp_ArgIndex];
    this->hp_ArgIndex += 1;

    return( retval );
}

void HeyParser::nextProperty(const char *&name_out, const char *&value_out)
    throw (HeyParserException)
{
    const char *arg;
    
    name_out = NULL;
    value_out = NULL;
    
    if( (this->hp_ArgIndex > 3) ||
        ((this->hp_What == GET_SUITES) && (this->hp_ArgIndex == 3)) )
    {
        /* Expect 'of' after the first property is processed. */
        if( strcasecmp(this->consumeArg(), "of") == 0 )
        {
        }
        else
        {
            throw HeyParserException("Expecting 'of' keyword");
        }
    }

    /* The property name is always required. */
    name_out = this->consumeArg();
    try
    {
        arg = this->consumeArg();
        if( (strcasecmp(arg, "of") == 0) ||
            (strcasecmp(arg, "to") == 0) ||
            (strcasecmp(arg, "with") == 0) )
        {
            /*
             * Detected a preposition separating properties.  Back up since it
             * will be consumed on the next go around.
             */
            this->hp_ArgIndex -= 1;
        }
        else
        {
            value_out = arg;
        }
    }
    catch(const HeyParserException &e)
    {
        /* Ignore missing value. */
    }
}

void HeyParser::popProperty(const char *&name_out, const char *&value_out)
    throw (HeyParserException)
{
    struct Pair pair;

    name_out = NULL;
    value_out = NULL;
    
    if( this->hp_PropertyStack.size() == 0 )
    {
        throw HeyParserException("No more properties");
    }
    
    pair = this->hp_PropertyStack.top();
    name_out = pair.p_Name;
    value_out = pair.p_Value;
    this->hp_PropertyStack.pop();
}

void HeyParser::with(const char **&with_out, size_t &count_out) const
{
    with_out = &this->hp_ArgValue[this->hp_ArgIndex];
    count_out = this->hp_ArgCount - this->hp_ArgIndex;
}

const char *HeyParser::withValue(const char *name,
                                 unsigned int instance,
                                 const char *default_value) const
    throw (HeyParserException)
{
    const char *retval = NULL;
    size_t name_len;
    int lpc;

    require(name != NULL);

    name_len = strlen(name);
    /* Walk over the arguments not consumed by the constructor. */
    for( lpc = this->hp_ArgIndex;
         (lpc < this->hp_ArgCount) && (retval == NULL);
         lpc += 2 )
    {
        /* Compare the first part of the string to see if we have */
        if( (strncasecmp(this->hp_ArgValue[lpc], name, name_len) == 0) &&
            /* ... a complete match or */
            ((this->hp_ArgValue[lpc][name_len] == '\0') ||
             /* ... a value concatenated. */
             (this->hp_ArgValue[lpc][name_len] == '=')) )
        {
            if( instance == 0 )
            {
                if( this->hp_ArgValue[lpc][name_len] == '=' )
                {
                    retval = &this->hp_ArgValue[lpc][name_len + 1];
                }
                else
                {
                    retval = this->hp_ArgValue[lpc + 1];
                }
            }
            else
            {
                instance -= 1;
            }
        }
    }

    if( retval == NULL )
    {
        if( default_value != NULL )
        {
            retval = default_value;
        }
        else
        {
            throw HeyParserException("Missing value", name);
        }
    }
    
    return( retval );
}

---