valuechangeparser.cpp

机器人开源项目orocos的源代码

        //peername  = peerparser.peer();
        // the peerparser.object() should contain "this"
        //peerparser.reset();
        // reset the Property parser to traverse this peers bag :
        propparser.setPropertyBag( peerparser.peer()->properties() ); // may be null. ok.
    }

    void ValueChangeParser::seenvariabledefinition()
    {
        // build type.
        AttributeBase* var;
        if (sizehint == -1 )
            var = type->buildVariable(valuename);
        else {
            var = type->buildVariable(valuename,sizehint);
        }
        mstore->attributes()->setValue( var );
        definedvalues.push_back( var );
        definednames.push_back( valuename );
        alldefinednames.push_back( valuename );

        if ( expressionparser.hasResult() ) {
            DataSourceBase::shared_ptr expr = expressionparser.getResult();
            expressionparser.dropResult();
            //assert( !expressionparser.hasResult() );
#ifndef ORO_EMBEDDED
            try {
                CommandInterface* ac = var->getDataSource()->updateCommand( expr.get() );
                assert(ac);
                assigncommands.push_back( ac );
            }
            catch( const bad_assignment& e ) {
                this->cleanup();
                throw parse_exception_semantic_error
                    ( "Attempt to initialize a var "+var->getDataSource()->getTypeName()+" with a "+ expr->getTypeName() + "." );
            }
#else
            CommandInterface* ac = var->getDataSource()->updateCommand( expr.get() );
            if (ac)
                assigncommands.push_back( ac );
            else {
                this->cleanup();
                return;
            }
#endif
        }
    }

    void ValueChangeParser::seenvariableassignment()
    {
        AttributeBase* var = 0;
        PropertyBase*     prop = 0;

        OperationInterface* peername = peerparser.taskObject();
        peerparser.reset();
 
        // if bag is non-null, 'valuename' must be one of its properties :
        if ( propparser.bag() && propparser.property() ) {
            // propparser.property() is the Property<PropertyBag> of a nested bag() :
            // valuename is the element of this bag.
            // we need to use Property assignment commands instead of
            // taskattributebase assignment commands lateron.
            prop = propparser.bag()->find( valuename );
            if ( prop == 0 )
                throw parse_exception_semantic_error( "In "+context->getName()+": Property \"" + valuename + "\" not defined in nested PropertyBag '"+propparser.property()->getName()+"' of TaskObject '"+peername->getName()+"'." );

            propparser.reset();
        } else {
            // first check if it is a property :
            if ( peername->attributes()->hasProperty( valuename ) ) {
                prop =  peername->attributes()->properties()->find( valuename );
            } else {
                // not a property case :
                var = peername->attributes()->getValue( valuename );
                // SIDENOTE: now, we must be sure that if this program gets copied,
                // the DS still points to the peer's attribute, and not to a new copy. Attribute and Properties
                // takes care of this by definition, but the variable of a loaded StateMachine or program
                // must first get an instantiation-copy() before they become uncopyable. 
                if ( !var ) {
                    //DumpObject( context );
                    throw parse_exception_semantic_error(  "In "+context->getName()+": Attribute \"" + valuename + "\" not defined in task '"+peername->getName()+"'." );
                }
            }
        }

        // collect RHS :
        DataSourceBase::shared_ptr expr = expressionparser.getResult();
        assert( expr );
        expressionparser.dropResult();
        //assert( !expressionparser.hasResult() );

        if ( index_ds && prop ) {
            //           throw parse_exception_semantic_error(
            //               "Cannot use index with Property<"+prop->getType()+"> " + valuename + " inside PropertyBag. Not Implemented. Add Propery as Attribute to allow index assignment." );
            CommandInterface* ac;
#ifndef ORO_EMBEDDED
            try {
                ac = prop->getDataSource()->updatePartCommand( index_ds.get(), expr.get() );
            }
            catch( const bad_assignment& e) {
                // type-error :
                throw parse_exception_semantic_error(
                                                     "Impossible to assign "+valuename+"[ "+index_ds->getTypeName()+" ] to value of type "+expr->getTypeName()+".");
            }
            // not allowed :
            if ( !ac )
                throw parse_exception_semantic_error(
                                                     "Cannot use index with constant, alias or non-indexed value \"" + valuename + "\"." );
            assigncommands.push_back( ac );
#else
            ac = prop->getDataSource()->updatePartCommand( index_ds.get(), expr.get() );
            if (ac)
                assigncommands.push_back( ac );
            else
                return;
#endif
        }

        if ( index_ds && var ) {
            CommandInterface* ac;
#ifndef ORO_EMBEDDED
            try {
                ac = var->getDataSource()->updatePartCommand( index_ds.get(), expr.get() );
                assigncommands.push_back( ac );
            }
            catch( const bad_assignment& e) {
                // type-error :
                throw parse_exception_semantic_error(
                                                     "Impossible to assign "+valuename+"[ "+index_ds->getTypeName()+" ] to value of type "+expr->getTypeName()+".");
            }
            // not allowed :
            if ( !ac )
                throw parse_exception_semantic_error(
                                                     "Cannot use index with constant, alias or non-indexed value \"" + valuename + "\"." );
#else
            ac = var->getDataSource()->updatePartCommand( index_ds.get(), expr.get() );
            if (ac)
                assigncommands.push_back( ac );
            else
                return;
#endif
        } 
        if ( !index_ds && var) {
#ifndef ORO_EMBEDDED
            try {
                CommandInterface* assigncommand = var->getDataSource()->updateCommand( expr.get() );
                assigncommands.push_back(assigncommand);
                // if null, not allowed.
                if ( ! assigncommand )
                    throw parse_exception_semantic_error( "Cannot set constant or alias \"" + valuename + "\" in OperationInterface "+ peername->getName()+"." );
            }
            catch( const bad_assignment& e )
                {
                    // type-error :
                    throw parse_exception_semantic_error
                        ( "Attempt to assign variable of type "+var->getDataSource()->getTypeName()+" with a "+ expr->getTypeName() + "." );
                }
#else
            CommandInterface* assigncommand = var->getDataSource()->updateCommand( expr.get() );
            if (assigncommand)
                assigncommands.push_back(assigncommand);
            else
                return;
#endif
        }
        if ( !index_ds && prop) {
#ifndef ORO_EMBEDDED
            try {
                CommandInterface* assigncommand = prop->getDataSource()->updateCommand( expr.get() );
                if ( ! assigncommand ) {
                    throw parse_exception_semantic_error( "Cannot set Property<"+ prop->getType() +"> " + valuename + " to value of type "+expr->getTypeName()+"." );
                }
                assigncommands.push_back(assigncommand);
            }
            catch( bad_assignment& ) {
                throw parse_exception_semantic_error
                    ( "Attempt to assign property of type "+prop->getDataSource()->getTypeName()+" with a "+ expr->getTypeName() + "." );
            }
#else
            CommandInterface* assigncommand = prop->getDataSource()->updateCommand( expr.get() );
            if ( assigncommand )
                assigncommands.push_back(assigncommand);
            else
                return;
#endif
        }

        // allow to restart over...
        index_ds = 0;
    }

    void ValueChangeParser::seenindexassignment()
    {
        index_ds = expressionparser.getResult();
        expressionparser.dropResult();
        assert(index_ds);
        //assert( !expressionparser.hasResult() );
    }

    void ValueChangeParser::store(OperationInterface* o)
    {
        for(std::vector<std::string>::iterator it = alldefinednames.begin();
            it != alldefinednames.end(); ++it) {
            o->attributes()->setValue( mstore->attributes()->getValue(*it)->clone() );
        }
    }

    void ValueChangeParser::cleanup()
    {
        for_each(assigncommands.begin(), assigncommands.end(), boost::lambda::bind(boost::lambda::delete_ptr(), boost::lambda::_1));
    }

    void ValueChangeParser::clear()
    {
        assigncommands.clear();
    
        definedvalues.clear();

        definednames.clear();
    }

    void ValueChangeParser::reset()
    {
        // erase/delete added values from the context:
        for(std::vector<std::string>::iterator it = alldefinednames.begin();
            it != alldefinednames.end(); ++it) {
            mstore->attributes()->removeValue( *it );
        }
        alldefinednames.clear();
        this->cleanup();
        this->clear();
        valuename = "";
        type = 0;
        index_ds = 0;
        sizehint = -1;
        peerparser.reset();
        propparser.reset();
    }

    rule_t& ValueChangeParser::constantDefinitionParser()
    {
        return constantdefinition;
    }

    rule_t& ValueChangeParser::aliasDefinitionParser()
    {
        return aliasdefinition;
    }

    rule_t& ValueChangeParser::variableDefinitionParser()
    {
        return variabledefinition;
    }

    rule_t& ValueChangeParser::variableAssignmentParser()
    {
        return variableassignment;
    }

    rule_t& ValueChangeParser::variableChangeParser()
    {
        return variablechange;
    }

    rule_t& ValueChangeParser::paramDefinitionParser()
    {
        return paramdefinition;
    }

    rule_t& ValueChangeParser::bareDefinitionParser()
    {
        return baredefinition;
    }
}