grammar.h

Go to the documentation of this file.

/*******************************************************************************
 * wallaroo - A library for configurable creation and wiring of C++ classes.
 * Copyright (C) 2012 Daniele Pallastrelli
 *
 * This file is part of wallaroo.
 * For more information, see http://wallaroolib.sourceforge.net/
 *
 * Boost Software License - Version 1.0 - August 17th, 2003
 *
 * Permission is hereby granted, free of charge, to any person or organization
 * obtaining a copy of the software and accompanying documentation covered by
 * this license (the "Software") to use, reproduce, display, distribute,
 * execute, and transmit the Software, and to prepare derivative works of the
 * Software, and to permit third-parties to whom the Software is furnished to
 * do so, all subject to the following:
 *
 * The copyright notices in the Software and this entire statement, including
 * the above license grant, this restriction and the following disclaimer,
 * must be included in all copies of the Software, in whole or in part, and
 * all derivative works of the Software, unless such copies or derivative
 * works are solely in the form of machine-executable object code generated by
 * a source language processor.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
 * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 ******************************************************************************/

#ifndef WALLAROO_DETAIL_GRAMMAR_H_
#define WALLAROO_DETAIL_GRAMMAR_H_

#include <string>
#include <sstream>
#include "wallaroo/exceptions.h"
#include "wallaroo/detail/tokensource.h"

namespace wallaroo
{
namespace detail
{

/*
GRAMMAR

    start          ->  list <done>
    list           ->  statement <stmtsep> list | <empty>
    statement      ->  loadexpr | assignexpr
    loadexpr       ->  <load> <value>
    assignexpr     ->  <id> <assign> <create> <id> <optparamlist> | <id> depexpr
    optparamlist   ->  <empty> | <open> attrlist <close>
    attrlist       ->  <empty> | attrassign moreattrassign
    attrassign     ->  <id> <assign> <value>
    moreattrassign ->  <empty> | <attrsep> attrassign    
    depexpr        ->  <collsep> <id> <assign> <id>

e.g.:
    load value;
    id = new id ( id=value, id=value, ... );
    id.id=id;

    ---

    load "plugin.so";
    dev = new Device ( name="dev1", port=30, load=3.14 );
    dev2 = new Device2;
    dev.dep = dev2;

terminals:
    "load"  <load>
    "new"   <create>
    "("
    ")"
    ";"
    ","
    "="
    "."
    id
    value
    done
*/

template < typename SemanticActions >
class Grammar
{
public:
    Grammar( std::istream& in, SemanticActions& sa ) : 
        input( in ), lookahead( Token::done ), actions( sa ) 
    {}

    // throws SyntaxError
    // start -> list <done>
    // list -> statement <stmtsep> list | <empty>
    void Parse()
    {
        lookahead = input.Next();
        while ( lookahead.type != Token::done )
        {
            Statement();
            Match( Token::stmtsep );
        }
    }
private:
    // statement -> loadexpr | assignexpr
    void Statement()
    {
        switch ( lookahead.type )
        {
            case Token::load: LoadExpr(); break;
            case Token::id: AssignExpr(); break;
            default:
                throw SyntaxError( "expecting load, create or id", input.Line(), input.Col() ); // TODO: expecting load, create or id
        }
    }
    // loadexpr -> <load> <value>
    void LoadExpr()
    {
        Match( Token::load );
        const std::string value = NextLexem();
        Match( Token::value );
        actions.Load( value );
    }
    // assignexpr     ->  <id> <assign> <create> <id> <optparamlist> | <id> depexpr
    // optparamlist   ->  <empty> | <open> attrlist <close>
    // attrlist       ->  <empty> | attrassign moreattrassign
    // attrassign     ->  <id> <assign> <value>
    // moreattrassign ->  <empty> | <attrsep> attrassign    
    // depexpr        ->  <collsep> <id> <assign> <id>
    void AssignExpr()
    {
        const std::string lvalue = NextLexem();
        Match( Token::id );
        switch ( lookahead.type )
        {
            case Token::assign:
            {
                Match( Token::assign );
                Match( Token::create );
                const std::string rvalue = NextLexem();
                Match( Token::id );
                if ( lookahead.type == Token::open )
                {
                    Match( Token::open );
                    while ( lookahead.type == Token::id )
                    {
                        const std::string attId = NextLexem();
                        Match( Token::id );
                        Match( Token::assign );
                        const std::string attValue = NextLexem();
                        Match( Token::value );
                        actions.AssignAttribute( lvalue, attId, attValue );
                        if ( lookahead.type == Token::attrsep ) Match( Token::attrsep );
                    }
                    Match( Token::close );
                }
                actions.Create( lvalue, rvalue );
                break;
            }
            case Token::collsep:
            {
                Match( Token::collsep );
                const std::string dep = NextLexem();
                Match( Token::id );
                Match( Token::assign );
                const std::string rvalue = NextLexem();
                Match( Token::id );
                actions.AssignDep( lvalue, dep, rvalue );
                break;
            }
            default:
                throw SyntaxError( "expecting = or .", input.Line(), input.Col() ); // TODO
        }
    }
    void Match( Token::Type t )
    {
        if ( lookahead.type == t ) lookahead = input.Next();
        else throw SyntaxError( "expecting token " + Token::Description( t ), input.Line(), input.Col() ); // TODO error msg (e.g., "expecting t")
    }
    std::string NextLexem() const
    {
        return lookahead.lexem;
    }
    TokenSource input;
    Token lookahead;
    SemanticActions& actions;
};

} // detail
} // namespace

#endif // WALLAROO_DETAIL_GRAMMAR_H_