---

Automaton.h

Go to the documentation of this file.

/*
 * Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 * USA.
 */
#ifndef PARSER_AUTOMATON_H
#define PARSER_AUTOMATON_H

#include <iostream.h>

#include "MNList.h"
#include "MNArray.h"
#include "dictionary.h"

#include "V2States.h"

class Action;
class TargetState;
class V1StateVector;
class V2StateCollector;
class StateTransitionArray;

/***********************************************************************
 * StateTransitionPair
 ***********************************************************************/

class StateTransitionPair
{
    MNList<V2StateVector*> _vectors;
public:
    StateTransitionPair( );

    void append( int dim_count, int* vector );
    void append( V2StateVector* v );

    MNList<V2StateVector*>& vectors();
};

/***********************************************************************
 * StateTransitionCollection
 ***********************************************************************/

class StateTransitionCollection
    : public MNdictionary<V1Transition*,StateTransitionPair*>
{
public:
    virtual int compare(V1Transition *const & l, V1Transition *const & r) const;
};

/***********************************************************************
 * Automaton
 ***********************************************************************/

class Automaton
{
    bool        _sync_stop;

    const char* _user_code_header;
    const char* _user_header;
    const char* _user_class_elements;
    const char* _user_code;
    const char* _inherit_class;
    const char* _inherit_class_init;
    const char* _constructor_parameters;
    const char* _constructor_parameter_assignment;
    const char* _constructor_body;
    const char* _destructor_body;
    const char* _entertrans_code;
    const char* _enterstate_code;

    int         _user_code_header_line;
    int         _user_header_line;
    int         _user_class_elements_line;
    int         _user_code_line;

    V2StateCollector* _collector;

    char* _automaton_name;
    char* _automaton_class_name;
    char* _target_file_name;
    char* _source_file_name;

    // typedef MNList<V1Transition*>             TransitionList;
    // typedef MNArray2<V1Transition*>           TransitionArray;

    // typedef dictionary<int,TransitionList*> TransitionTable;
    // MNList<StateTransitionPair*> _transitionCollector;
    // TransitionTable              _ttable;

    // dictionary<int,int> _state_to_statename;
    // dictionary<int,int> _input_to_inputname;
    dictionary<int,SignalParameterList*> _inputname_to_input_definition;

    void dump_nextstate_macro_recurse( ostream& ostr, int dim, int maxd, int* vector );
    void dump_nextstate_macro( ostream& ostr, int del, StateTransitionArray* array );
    void dump_nextstate_impl( ostream& ostr, StateTransitionArray* array );
    void dump_statename_impl( ostream& ostr, StateTransitionArray* array );
    void dump_enterstate_impl( ostream& ostr );
    void dump_entertrans_impl( ostream& ostr );
    void dump_user_header ( ostream& );
    void dump_user_code_header ( ostream& );
    void dump_user_class_elements ( ostream& );
    void dump_state_enum( ostream&, StateTransitionArray* array );
    void dump_input_enum( ostream& );
    void dump_input_calls( ostream& ostr, int decl, StateTransitionArray* array );
    void dump_signal_calls( ostream& ostr, int decl, StateTransitionArray* array );
    void dump_signal_classes( ostream& ostr, int decl );
    void dump_constructor( ostream& ostr, int decl );
    void dump_user_code( ostream& ostr );
public:
    Automaton();
    void setName ( const char* s );

    void setFilename ( int prefix );
    void setCodePrefix ( const char* prefix, int codeblockline );
    void setPrefix ( const char* prefix, int codeblockline );
    void setDeclare ( const char* declaration, int codeblockline );
    void setDefine ( const char* definition, int codeblockline );
    void setInherit ( int inherit_class );
    void setInherit ( int inherit_class, const char* inherit_class_init );
    void setInherit ( const char* inherit_class );
    void setInherit ( const char* inherit_class, const char* inherit_class_init );
    void setConstruct ( const char* parameters,
                        const char* assignment = NULL,
                        const char* body = NULL );
    void setDestruct ( const char* body );
    void setEnterstate ( const char* body );
    void setEntertrans ( const char* body );
    void setSyncStop ( );
    void inputDefinition ( int name, SignalParameterList* parameters );

    void respace ( ostream& ostr,
                   const char* str,
                   const char* input );

    void eval ( V2StateCollector* v2, StateTransitionArray* array );
};

extern Automaton automaton;

#endif /* PARSER_AUTOMATON_H */

---