00001
00004 #ifndef DIVINE_DVE_PROCESS_HH
00005 #define DIVINE_DVE_PROCESS_HH
00006
00007 #ifndef DOXYGEN_PROCESSING
00008 #include <iostream>
00009 #include <string>
00010 #include <sstream>
00011 #include "system/process.hh"
00012 #include "common/error.hh"
00013 #include "common/array.hh"
00014 #include "system/dve/dve_transition.hh"
00015 #include "common/deb.hh"
00016
00017
00018 namespace divine {
00019 using std::cerr; using std::endl;
00020 #endif //DOXYGEN_PROCESSING
00021
00022 DEB(using namespace std;)
00023
00024 class dve_symbol_table_t;
00025 class dve_transition_t;
00026 class dve_expression_t;
00027 class dve_parser_t;
00028
00031 const size_int_t DVE_PROCESS_ALLOC_STEP = 20;
00032
00034
00045 class dve_process_t: public virtual process_t
00046 {
00047 private:
00048 static dve_parser_t proc_parser;
00049
00050
00051 array_t<dve_transition_t *> transitions;
00052 array_t<dve_transition_t *> trans_by_sync[5];
00053 size_int_t initial_state;
00054 property_type_t accepting_type;
00055 size_int_t accepting_groups;
00056 array_t<bool> *accepting1;
00057 array_t<bool> *accepting2;
00058 array_t<bool> commited;
00059
00060
00061 array_t<size_int_t> var_gids;
00062 array_t<size_int_t> state_gids;
00063 bool valid;
00064
00065
00066 array_t< array_t<dve_expression_t *> * > assertions;
00067
00068 void intitialize_dve_specific_parts();
00069
00070 protected:
00071 void write_declarations(std::ostream & ostr) const;
00072 int read_using_given_parser(std::istream & istr, dve_parser_t & parser);
00073
00074 public:
00077 dve_process_t();
00079 dve_process_t(system_t * const system);
00081 virtual ~dve_process_t();
00083
00084 virtual std::string to_string() const;
00086 virtual void write(std::ostream & ostr) const;
00092
00093
00094 virtual transition_t * get_transition(const size_int_t lid)
00095 { return transitions[lid]; }
00098 virtual const transition_t * get_transition(const size_int_t lid) const
00099 { return transitions[lid]; }
00101 virtual size_int_t get_trans_count() const { return transitions.size(); }
00108
00109
00110
00113 virtual void add_transition(transition_t * const transition);
00115 virtual void remove_transition(const size_int_t transition_lid)
00116 { transitions[transition_lid]->set_valid(false); }
00124
00125 virtual int from_string(std::string & proc_str);
00127 virtual int read(std::istream & istr);
00130
00131
00136
00137 bool get_valid() const { return valid; }
00138
00141
00146 dve_transition_t * get_transition(const sync_mode_t sync_mode,
00147 const size_int_t trans_nbr)
00148 { return trans_by_sync[sync_mode][trans_nbr]; }
00152 const dve_transition_t * get_transition(const sync_mode_t sync_mode,
00153 const size_int_t trans_nbr) const
00154 { return trans_by_sync[sync_mode][trans_nbr]; }
00156
00162 size_int_t get_trans_count(const sync_mode_t sync_mode) const
00163 { return trans_by_sync[sync_mode].size(); }
00164
00166 size_int_t get_variable_count() const { return var_gids.size(); }
00168 size_int_t get_variable_gid(size_int_t lid) const { return var_gids[lid]; }
00170 size_int_t get_state_count() const { return state_gids.size(); }
00172 size_int_t get_state_gid(size_int_t lid) const { return state_gids[lid]; }
00174 size_int_t get_initial_state() const { return initial_state; }
00175
00177 void set_valid(const bool is_valid) { valid = is_valid; }
00179
00182 void set_initial_state(const size_int_t state_lid)
00183 { initial_state = state_lid; }
00184
00187 bool get_acceptance(size_int_t lid, size_int_t group=0, size_int_t pair_member=1) const
00188 {
00189 if (pair_member==1)
00190 {
00191 return (lid<=(accepting1[group].size()) && (accepting1[group][lid]));
00192 }
00193 else
00194 {
00195 return (lid<=(accepting2[group].size()) && (accepting2[group][lid]));
00196 }
00197 }
00198
00201 void set_acceptance(size_int_t lid, bool is_accepting, size_int_t group=0, size_int_t pair_member=1)
00202 {
00203 DEB(cerr <<"Set acceptance:"<<lid<<"("<<is_accepting<<") group:"<<group<<" pair:"<<pair_member<<endl;)
00204 if (pair_member==1)
00205 {
00206 (accepting1[group])[lid] = is_accepting;
00207 }
00208 else
00209 {
00210 (accepting2[group])[lid] = is_accepting;
00211 }
00212 }
00213
00215 void set_acceptance_type_and_groups(property_type_t prop_type,size_int_t groups_count)
00216 {
00217 DEB(cerr<<"Acc type:"<< prop_type<<" with "<<groups_count<<" groups."<<endl;);
00218 accepting_type = prop_type;
00219 accepting_groups = groups_count;
00220 accepting1= new array_t<bool>[groups_count];
00221 accepting2= new array_t<bool>[groups_count];
00222
00223 for (size_int_t i=0; i!=accepting_groups; ++i)
00224 {
00225 accepting1[i].resize(state_gids.size());
00226 accepting2[i].resize(state_gids.size());
00227 for (size_int_t j=0; j!=state_gids.size(); ++j)
00228 {
00229 accepting1[i][j] = false;
00230 accepting2[i][j] = false;
00231 }
00232 }
00233 }
00234
00238 size_int_t get_accepting_group_count() const { return accepting_groups; }
00239
00241 property_type_t get_accepting_type() const { return accepting_type; }
00242
00244 bool get_commited(size_int_t lid) const
00245 { return ((lid<=commited.size()) && commited[lid]); }
00247 void set_commited(size_int_t lid, bool is_commited)
00248 { commited[lid] = is_commited; }
00249
00252 void add_variable(const size_int_t var_gid);
00255 void add_state(const size_int_t state_gid);
00256
00258 size_int_t get_assertion_count(const size_int_t state_lid) const
00259 { return assertions[state_lid]->size(); }
00260
00262
00265 dve_expression_t * get_assertion(const size_int_t state_lid,
00266 const size_int_t index)
00267 { return (*assertions[state_lid])[index]; }
00268
00270
00273 const dve_expression_t * get_assertion(const size_int_t state_lid,
00274 const size_int_t index) const
00275 { return (*assertions[state_lid])[index]; }
00276
00278
00279 void add_assertion(size_int_t state_lid,dve_expression_t * const assert_expr);
00280
00281
00283 dve_symbol_table_t * get_symbol_table() const;
00285 };
00286
00287
00288 #ifndef DOXYGEN_PROCESSING
00289 }
00290 #include "common/undeb.hh"
00291
00292 #endif //DOXYGEN_PROCESSING
00293
00294 #endif
00295
00296