Mercurial Mercurial > matiec / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
stage4/generate_c/generate_c_sfc.cc
changeset 258 d7d92b2f87e9
parent 244 3a478229db8b
child 279 c0453b7f99df
equal deleted inserted replaced
257:90782e241346 258:d7d92b2f87e9 
    36   transition_c *symbol;
 
    36   transition_c *symbol;
 
    37   int priority;
 
    37   int priority;
 
    38   int index;
 
    38   int index;
 
    39 } TRANSITION;
 
    39 } TRANSITION;
 
    40 
    40 
    41 
       
    42 
       
    43 
       
    44 
       
    45 /***********************************************************************/
 
    41 /***********************************************************************/
 
    46 /***********************************************************************/
 
    42 /***********************************************************************/
 
    47 /***********************************************************************/
 
    43 /***********************************************************************/
 
    48 /***********************************************************************/
 
    44 /***********************************************************************/
 
    49 
    45 
    62 
    58 
    63   private:
 
    59   private:
 
    64     generate_c_il_c *generate_c_il;
 
    60     generate_c_il_c *generate_c_il;
 
    65     generate_c_st_c *generate_c_st;
 
    61     generate_c_st_c *generate_c_st;
 
    66     generate_c_SFC_IL_ST_c *generate_c_code;
 
    62     generate_c_SFC_IL_ST_c *generate_c_code;
 
    67     search_var_instance_decl_c *search_var_instance_decl;
 
       
    68     
    63     
    69     int transition_number;
 
    64     int transition_number;
 
    70     std::list<TRANSITION> transition_list;
 
    65     std::list<TRANSITION> transition_list;
 
    71     
    66     
    72     symbol_c *current_step;
 
    67     symbol_c *current_step;
 
    73     symbol_c *current_action;
 
    68     symbol_c *current_action;
 
    74 
    69 
    75     sfcgeneration_t wanted_sfcgeneration;
 
    70     sfcgeneration_t wanted_sfcgeneration;
 
    76     
    71     
    77   public:
 
    72   public:
 
    78     generate_c_sfc_elements_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL)
 
    73     generate_c_sfc_elements_c(stage4out_c *s4o_ptr, symbol_c *name, symbol_c *scope, const char *variable_prefix = NULL)
 
    79     : generate_c_base_c(s4o_ptr) {
 
    74     : generate_c_base_c(s4o_ptr) {
 
    80       generate_c_il = new generate_c_il_c(s4o_ptr, scope, variable_prefix);
 
    75       generate_c_il = new generate_c_il_c(s4o_ptr, name, scope, variable_prefix);
 
    81       generate_c_st = new generate_c_st_c(s4o_ptr, scope, variable_prefix);
 
    76       generate_c_st = new generate_c_st_c(s4o_ptr, name, scope, variable_prefix);
 
    82       generate_c_code = new generate_c_SFC_IL_ST_c(s4o_ptr, scope, variable_prefix);
 
    77       generate_c_code = new generate_c_SFC_IL_ST_c(s4o_ptr, name, scope, variable_prefix);
 
    83       search_var_instance_decl = new search_var_instance_decl_c(scope);
 
       
    84       this->set_variable_prefix(variable_prefix);
 
    78       this->set_variable_prefix(variable_prefix);
 
    85     }
 
    79     }
 
    86     
    80     
    87     ~generate_c_sfc_elements_c(void) {
 
    81     ~generate_c_sfc_elements_c(void) {
 
    88       transition_list.clear();
 
    82       transition_list.clear();
 
    89       delete generate_c_il;
 
    83       delete generate_c_il;
 
    90       delete generate_c_st;
 
    84       delete generate_c_st;
 
    91       delete generate_c_code;
 
    85       delete generate_c_code;
 
    92       delete search_var_instance_decl;
 
       
    93     }
 
    86     }
 
    94 
    87 
    95     void reset_transition_number(void) {transition_number = 0;}
 
    88     void reset_transition_number(void) {transition_number = 0;}
 
    96 
    89 
    97     void generate(symbol_c *symbol, sfcgeneration_t generation_type) {
 
    90     void generate(symbol_c *symbol, sfcgeneration_t generation_type) {
 
   129       s4o.print("].");
 
   122       s4o.print("].");
 
   130       s4o.print(argument);
 
   123       s4o.print(argument);
 
   131     }      
   124     }      
   132 
   125 
   133     void print_transition_number(void) {
 
   126     void print_transition_number(void) {
 
   134       char str[10];
 
   127       s4o.print_integer(transition_number);
 
   135       sprintf(str, "%d", transition_number);
 
       
   136       s4o.print(str);
 
       
   137     }
 
   128     }
 
   138 
   129 
   139     void print_reset_step(symbol_c *step_name) {
 
   130     void print_reset_step(symbol_c *step_name) {
 
   140       s4o.print(s4o.indent_spaces);
 
   131       s4o.print(s4o.indent_spaces);
 
       
   132       s4o.print(SET_VAR);
 
       
   133       s4o.print("(");
 
   141       print_step_argument(step_name, "state");
 
   134       print_step_argument(step_name, "state");
 
   142       s4o.print(" = 0;\n");
 
   135       s4o.print(",0);\n");
 
   143     }
 
   136     }
 
   144     
   137     
   145     void print_set_step(symbol_c *step_name) {
 
   138     void print_set_step(symbol_c *step_name) {
 
   146       s4o.print(s4o.indent_spaces);
 
   139       s4o.print(s4o.indent_spaces);
 
       
   140       s4o.print(SET_VAR);
 
       
   141       s4o.print("(");
 
   147       print_step_argument(step_name, "state");
 
   142       print_step_argument(step_name, "state");
 
   148       s4o.print(" = 1;\n" + s4o.indent_spaces);
 
   143       s4o.print(",1);\n" + s4o.indent_spaces);
 
   149       print_step_argument(step_name, "elapsed_time");
 
   144       print_step_argument(step_name, "elapsed_time");
 
   150       s4o.print(" = __time_to_timespec(1, 0, 0, 0, 0, 0);\n");
 
   145       s4o.print(" = __time_to_timespec(1, 0, 0, 0, 0, 0);\n");
 
   151     }
 
   146     }
 
   152     
   147     
   153     bool is_variable(symbol_c *symbol) {
 
       
   154       /* we try to find the variable instance declaration, to determine its type... */
 
       
   155       symbol_c *var_decl = search_var_instance_decl->get_decl(symbol);
 
       
   156       
       
   157       return var_decl != NULL;
 
       
   158     }
 
       
   159 
       
   160 /*********************************************/
 
   148 /*********************************************/
 
   161 /* B.1.6  Sequential function chart elements */
 
   149 /* B.1.6  Sequential function chart elements */
 
   162 /*********************************************/
 
   150 /*********************************************/
 
   163     
   151     
   164     void *visit(initial_step_c *symbol) {
 
   152     void *visit(initial_step_c *symbol) {
 
   170             s4o.print(" action associations\n");
 
   158             s4o.print(" action associations\n");
 
   171             current_step = symbol->step_name;
 
   159             current_step = symbol->step_name;
 
   172             s4o.print(s4o.indent_spaces + "{\n");
 
   160             s4o.print(s4o.indent_spaces + "{\n");
 
   173             s4o.indent_right();
 
   161             s4o.indent_right();
 
   174             s4o.print(s4o.indent_spaces + "char activated = ");
 
   162             s4o.print(s4o.indent_spaces + "char activated = ");
 
       
   163             s4o.print(GET_VAR);
 
       
   164             s4o.print("(");
 
   175             print_step_argument(current_step, "state");
 
   165             print_step_argument(current_step, "state");
 
   176             s4o.print(" && !");
 
   166             s4o.print(") && !");
 
   177             print_step_argument(current_step, "prev_state");
 
   167             print_step_argument(current_step, "prev_state");
 
   178             s4o.print(";\n");
 
   168             s4o.print(";\n");
 
   179             s4o.print(s4o.indent_spaces + "char desactivated = !");
 
   169             s4o.print(s4o.indent_spaces + "char desactivated = !");
 
       
   170             s4o.print(GET_VAR);
 
       
   171             s4o.print("(");
 
   180             print_step_argument(current_step, "state");
 
   172             print_step_argument(current_step, "state");
 
   181             s4o.print(" && ");
 
   173             s4o.print(") && ");
 
   182             print_step_argument(current_step, "prev_state");
 
   174             print_step_argument(current_step, "prev_state");
 
   183             s4o.print(";\n");
 
   175             s4o.print(";\n");
 
   184             s4o.print(s4o.indent_spaces + "char active = ");
 
   176             s4o.print(s4o.indent_spaces + "char active = ");
 
       
   177             s4o.print(GET_VAR);
 
       
   178             s4o.print("(");
 
   185             print_step_argument(current_step, "state");
 
   179             print_step_argument(current_step, "state");
 
   186             s4o.print(";\n");
 
   180             s4o.print(");\n");
 
   187             symbol->action_association_list->accept(*this);
 
   181             symbol->action_association_list->accept(*this);
 
   188             s4o.indent_left();
 
   182             s4o.indent_left();
 
   189             s4o.print(s4o.indent_spaces + "}\n\n");
 
   183             s4o.print(s4o.indent_spaces + "}\n\n");
 
   190           }
 
   184           }
 
   191           break;
 
   185           break;
 
   204             s4o.print(" action associations\n");
 
   198             s4o.print(" action associations\n");
 
   205             current_step = symbol->step_name;
 
   199             current_step = symbol->step_name;
 
   206             s4o.print(s4o.indent_spaces + "{\n");
 
   200             s4o.print(s4o.indent_spaces + "{\n");
 
   207             s4o.indent_right();
 
   201             s4o.indent_right();
 
   208             s4o.print(s4o.indent_spaces + "char activated = ");
 
   202             s4o.print(s4o.indent_spaces + "char activated = ");
 
       
   203             s4o.print(GET_VAR);
 
       
   204             s4o.print("(");
 
   209             print_step_argument(current_step, "state");
 
   205             print_step_argument(current_step, "state");
 
   210             s4o.print(" && !");
 
   206             s4o.print(") && !");
 
   211             print_step_argument(current_step, "prev_state");
 
   207             print_step_argument(current_step, "prev_state");
 
   212             s4o.print(";\n");
 
   208             s4o.print(";\n");
 
   213             s4o.print(s4o.indent_spaces + "char desactivated = !");
 
   209             s4o.print(s4o.indent_spaces + "char desactivated = !");
 
       
   210             s4o.print(GET_VAR);
 
       
   211             s4o.print("(");
 
   214             print_step_argument(current_step, "state");
 
   212             print_step_argument(current_step, "state");
 
   215             s4o.print(" && ");
 
   213             s4o.print(") && ");
 
   216             print_step_argument(current_step, "prev_state");
 
   214             print_step_argument(current_step, "prev_state");
 
   217             s4o.print(";\n");
 
   215             s4o.print(";\n");
 
   218             s4o.print(s4o.indent_spaces + "char active = ");
 
   216             s4o.print(s4o.indent_spaces + "char active = ");
 
       
   217             s4o.print(GET_VAR);
 
       
   218             s4o.print("(");
 
   219             print_step_argument(current_step, "state");
 
   219             print_step_argument(current_step, "state");
 
   220             s4o.print(";\n");
 
   220             s4o.print(");\n");
 
   221             symbol->action_association_list->accept(*this);
 
   221             symbol->action_association_list->accept(*this);
 
   222             s4o.indent_left();
 
   222             s4o.indent_left();
 
   223             s4o.print(s4o.indent_spaces + "}\n\n");
 
   223             s4o.print(s4o.indent_spaces + "}\n\n");
 
   224           }
 
   224           }
 
   225           break;
 
   225           break;
 
   261           // Calculate transition value
 
   261           // Calculate transition value
 
   262           symbol->transition_condition->accept(*this);
 
   262           symbol->transition_condition->accept(*this);
 
   263           
   263           
   264           if (symbol->integer != NULL) {
 
   264           if (symbol->integer != NULL) {
 
   265             s4o.print(s4o.indent_spaces + "if (");
 
   265             s4o.print(s4o.indent_spaces + "if (");
 
       
   266             s4o.print(GET_VAR);
 
       
   267             s4o.print("(");
 
   266             print_variable_prefix();
 
   268             print_variable_prefix();
 
   267             s4o.print("__transition_list[");
 
   269             s4o.print("__transition_list[");
 
   268             print_transition_number();
 
   270             print_transition_number();
 
   269             s4o.print("]) {\n");
 
   271             s4o.print("])) {\n");
 
   270             s4o.indent_right();
 
   272             s4o.indent_right();
 
   271             wanted_sfcgeneration = stepreset_sg;
 
   273             wanted_sfcgeneration = stepreset_sg;
 
   272             symbol->from_steps->accept(*this);
 
   274             symbol->from_steps->accept(*this);
 
   273             wanted_sfcgeneration = transitiontest_sg;
 
   275             wanted_sfcgeneration = transitiontest_sg;
 
   274             s4o.indent_left();
 
   276             s4o.indent_left();
 
   285           symbol->transition_condition->accept(*this);
 
   287           symbol->transition_condition->accept(*this);
 
   286           wanted_sfcgeneration = transitiontest_sg;
 
   288           wanted_sfcgeneration = transitiontest_sg;
 
   287           s4o.indent_left();
 
   289           s4o.indent_left();
 
   288           s4o.print(s4o.indent_spaces + "}\n");
 
   290           s4o.print(s4o.indent_spaces + "}\n");
 
   289           s4o.print(s4o.indent_spaces);
 
   291           s4o.print(s4o.indent_spaces);
 
       
   292           s4o.print(SET_VAR);
 
       
   293           s4o.print("(");
 
   290           print_variable_prefix();
 
   294           print_variable_prefix();
 
   291           s4o.print("__transition_list[");
 
   295           s4o.print("__transition_list[");
 
   292           print_transition_number();
 
   296           print_transition_number();
 
   293           s4o.print("] = 0;\n");
 
   297           s4o.print("],0);\n");
 
   294           s4o.indent_left();
 
   298           s4o.indent_left();
 
   295           s4o.print(s4o.indent_spaces + "}\n");
 
   299           s4o.print(s4o.indent_spaces + "}\n");
 
   296           break;
 
   300           break;
 
   297         case stepset_sg:
 
   301         case stepset_sg:
 
   298           s4o.print(s4o.indent_spaces + "if (");
 
   302           s4o.print(s4o.indent_spaces + "if (");
 
       
   303           s4o.print(GET_VAR);
 
       
   304           s4o.print("(");
 
   299           print_variable_prefix();
 
   305           print_variable_prefix();
 
   300           s4o.print("__transition_list[");
 
   306           s4o.print("__transition_list[");
 
   301           print_transition_number();
 
   307           print_transition_number();
 
   302           s4o.print("]) {\n");
 
   308           s4o.print("])) {\n");
 
   303           s4o.indent_right();
 
   309           s4o.indent_right();
 
   304           symbol->to_steps->accept(*this);
 
   310           symbol->to_steps->accept(*this);
 
   305           s4o.indent_left();
 
   311           s4o.indent_left();
 
   306           s4o.print(s4o.indent_spaces + "}\n");
 
   312           s4o.print(s4o.indent_spaces + "}\n");
 
   307           transition_number++;
 
   313           transition_number++;
 
   308           break;
 
   314           break;
 
   309         case stepreset_sg:
 
   315         case stepreset_sg:
 
   310           if (symbol->integer == NULL) {
 
   316           if (symbol->integer == NULL) {
 
   311             s4o.print(s4o.indent_spaces + "if (");
 
   317             s4o.print(s4o.indent_spaces + "if (");
 
       
   318             s4o.print(GET_VAR);
 
       
   319             s4o.print("(");
 
   312             print_variable_prefix();
 
   320             print_variable_prefix();
 
   313             s4o.print("__transition_list[");
 
   321             s4o.print("__transition_list[");
 
   314             print_transition_number();
 
   322             print_transition_number();
 
   315             s4o.print("]) {\n");
 
   323             s4o.print("])) {\n");
 
   316             s4o.indent_right();
 
   324             s4o.indent_right();
 
   317             symbol->from_steps->accept(*this);
 
   325             symbol->from_steps->accept(*this);
 
   318             s4o.indent_left();
 
   326             s4o.indent_left();
 
   319             s4o.print(s4o.indent_spaces + "}\n");
 
   327             s4o.print(s4o.indent_spaces + "}\n");
 
   320           }
 
   328           }
 
   333           // Transition condition is in IL
 
   341           // Transition condition is in IL
 
   334           if (symbol->transition_condition_il != NULL) {
 
   342           if (symbol->transition_condition_il != NULL) {
 
   335             generate_c_il->declare_backup_variable();
 
   343             generate_c_il->declare_backup_variable();
 
   336             s4o.print(s4o.indent_spaces);
 
   344             s4o.print(s4o.indent_spaces);
 
   337             symbol->transition_condition_il->accept(*generate_c_il);
 
   345             symbol->transition_condition_il->accept(*generate_c_il);
 
       
   346             s4o.print(SET_VAR);
 
       
   347             s4o.print("(");
 
   338             print_variable_prefix();
 
   348             print_variable_prefix();
 
   339             if (wanted_sfcgeneration == transitiontestdebug_sg)
 
   349             if (wanted_sfcgeneration == transitiontestdebug_sg)
 
   340               s4o.print("__debug_");
 
   350               s4o.print("__debug_");
 
   341             else
 
   351             else
 
   342               s4o.print("__");
 
   352               s4o.print("__");
 
   343             s4o.print("transition_list[");
 
   353             s4o.print("transition_list[");
 
   344             print_transition_number();
 
   354             print_transition_number();
 
   345             s4o.print("] = ");
 
   355             s4o.print("],");
 
   346             generate_c_il->print_backup_variable();
 
   356             generate_c_il->print_backup_variable();
 
   347             s4o.print(";\n");
 
   357             s4o.print(");\n");
 
   348           }
 
   358           }
 
   349           // Transition condition is in ST
 
   359           // Transition condition is in ST
 
   350           if (symbol->transition_condition_st != NULL) {
 
   360           if (symbol->transition_condition_st != NULL) {
 
   351             s4o.print(s4o.indent_spaces);
 
   361             s4o.print(s4o.indent_spaces);
 
       
   362             s4o.print(SET_VAR);
 
       
   363             s4o.print("(");
 
   352             print_variable_prefix();
 
   364             print_variable_prefix();
 
   353             if (wanted_sfcgeneration == transitiontestdebug_sg)
 
   365             if (wanted_sfcgeneration == transitiontestdebug_sg)
 
   354               s4o.print("__debug_");
 
   366               s4o.print("__debug_");
 
   355             else
 
   367             else
 
   356               s4o.print("__");
 
   368               s4o.print("__");
 
   357             s4o.print("transition_list[");
 
   369             s4o.print("transition_list[");
 
   358             print_transition_number();
 
   370             print_transition_number();
 
   359             s4o.print("] = ");
 
   371             s4o.print("],");
 
   360             symbol->transition_condition_st->accept(*generate_c_st);
 
   372             symbol->transition_condition_st->accept(*generate_c_st);
 
   361             s4o.print(";\n");
 
   373             s4o.print(");\n");
 
   362           }
 
   374           }
 
   363           if (wanted_sfcgeneration == transitiontest_sg) {
 
   375           if (wanted_sfcgeneration == transitiontest_sg) {
 
   364             s4o.print(s4o.indent_spaces + "if (__DEBUG) {\n");
 
   376             s4o.print(s4o.indent_spaces + "if (__DEBUG) {\n");
 
   365             s4o.indent_right();
 
   377             s4o.indent_right();
 
   366             s4o.print(s4o.indent_spaces);
 
   378             s4o.print(s4o.indent_spaces);
 
       
   379             s4o.print(SET_VAR);
 
       
   380             s4o.print("(");
 
   367             print_variable_prefix();
 
   381             print_variable_prefix();
 
   368             s4o.print("__debug_transition_list[");
 
   382             s4o.print("__debug_transition_list[");
 
   369             print_transition_number();
 
   383             print_transition_number();
 
   370             s4o.print("] = ");
 
   384             s4o.print("],");
 
       
   385             s4o.print(GET_VAR);
 
       
   386             s4o.print("(");
 
   371             print_variable_prefix();
 
   387             print_variable_prefix();
 
   372             s4o.print("__transition_list[");
 
   388             s4o.print("__transition_list[");
 
   373             print_transition_number();
 
   389             print_transition_number();
 
   374             s4o.print("];\n");
 
   390             s4o.print("]));\n");
 
   375             s4o.indent_left();
 
   391             s4o.indent_left();
 
   376             s4o.print(s4o.indent_spaces + "}\n");
 
   392             s4o.print(s4o.indent_spaces + "}\n");
 
   377           }
 
   393           }
 
   378           break;
 
   394           break;
 
   379         default:
 
   395         default:
 
   407 
   423 
   408     void *visit(steps_c *symbol) {
 
   424     void *visit(steps_c *symbol) {
 
   409       if (symbol->step_name != NULL) {
 
   425       if (symbol->step_name != NULL) {
 
   410         switch (wanted_sfcgeneration) {
 
   426         switch (wanted_sfcgeneration) {
 
   411           case transitiontest_sg:
 
   427           case transitiontest_sg:
 
       
   428         	s4o.print(GET_VAR);
 
       
   429         	s4o.print("(");
 
   412             print_step_argument(symbol->step_name, "state");
 
   430             print_step_argument(symbol->step_name, "state");
 
       
   431             s4o.print(")");
 
   413             break;
 
   432             break;
 
   414           case stepset_sg:
 
   433           case stepset_sg:
 
   415             print_set_step(symbol->step_name);
 
   434             print_set_step(symbol->step_name);
 
   416             break;
 
   435             break;
 
   417           case stepreset_sg:
 
   436           case stepreset_sg:
 
   429     
   448     
   430     void *visit(step_name_list_c *symbol) {
 
   449     void *visit(step_name_list_c *symbol) {
 
   431       switch (wanted_sfcgeneration) {
 
   450       switch (wanted_sfcgeneration) {
 
   432         case transitiontest_sg:
 
   451         case transitiontest_sg:
 
   433           for(int i = 0; i < symbol->n; i++) {
 
   452           for(int i = 0; i < symbol->n; i++) {
 
       
   453         	s4o.print(GET_VAR);
 
       
   454         	s4o.print("(");
 
   434             print_step_argument(symbol->elements[i], "state");
 
   455             print_step_argument(symbol->elements[i], "state");
 
       
   456             s4o.print(")");
 
   435             if (i < symbol->n - 1) {
 
   457             if (i < symbol->n - 1) {
 
   436               s4o.print(" && ");
 
   458               s4o.print(" && ");
 
   437             }
 
   459             }
 
   438           }
 
   460           }
 
   439           break;
 
   461           break;
 
   471             current_action = symbol->action_name;
 
   493             current_action = symbol->action_name;
 
   472             symbol->action_qualifier->accept(*this);
 
   494             symbol->action_qualifier->accept(*this);
 
   473           }
 
   495           }
 
   474           else {
 
   496           else {
 
   475             s4o.print(s4o.indent_spaces + "if (");
 
   497             s4o.print(s4o.indent_spaces + "if (");
 
       
   498             s4o.print(GET_VAR);
 
       
   499             s4o.print("(");
 
   476             print_step_argument(current_step, "state");
 
   500             print_step_argument(current_step, "state");
 
   477             s4o.print(") {\n");
 
   501             s4o.print(")) {\n");
 
   478             s4o.indent_right();
 
   502             s4o.indent_right();
 
   479             s4o.print(s4o.indent_spaces);
 
   503             s4o.print(s4o.indent_spaces);
 
   480             print_action_argument(symbol->action_name, "state");
 
   504             print_action_argument(symbol->action_name, "state");
 
   481             s4o.print(" = 1;\n");
 
   505             s4o.print(" = 1;\n");
 
   482             s4o.indent_left();
 
   506             s4o.indent_left();
 
   522                 strcmp(qualifier, "D") == 0 || strcmp(qualifier, "L") == 0) {
 
   546                 strcmp(qualifier, "D") == 0 || strcmp(qualifier, "L") == 0) {
 
   523               print_action_argument(current_action, "state");
 
   547               print_action_argument(current_action, "state");
 
   524               s4o.print(" = 1;\n");  
   548               s4o.print(" = 1;\n");  
   525             }
 
   549             }
 
   526             if (strcmp(qualifier, "S") == 0) {
 
   550             if (strcmp(qualifier, "S") == 0) {
 
   527               if (is_variable(current_action)) {
 
   551               print_action_argument(current_action, "set");
 
   528                 print_variable_prefix();
 
       
   529                 current_action->accept(*this);
 
       
   530               }
 
       
   531               else
 
       
   532                 print_action_argument(current_action, "set");
 
       
   533               s4o.print(" = 1;\n");
 
   552               s4o.print(" = 1;\n");
 
   534             }
 
   553             }
 
   535             if (strcmp(qualifier, "R") == 0) {
 
   554             if (strcmp(qualifier, "R") == 0) {
 
   536               if (is_variable(current_action)) {
 
   555               print_action_argument(current_action, "reset");
 
   537                 print_variable_prefix();
 
   556               s4o.print(" = 1;\n");
 
   538                 current_action->accept(*this);
 
       
   539                 s4o.print(" = 0;\n");
 
       
   540               }
 
       
   541               else {
 
       
   542                 print_action_argument(current_action, "reset");
 
       
   543                 s4o.print(" = 1;\n");
 
       
   544               }
 
       
   545             }
 
   557             }
 
   546             if (strcmp(qualifier, "SD") == 0 || strcmp(qualifier, "DS") == 0 || 
   558             if (strcmp(qualifier, "SD") == 0 || strcmp(qualifier, "DS") == 0 || 
   547                 strcmp(qualifier, "SL") == 0) {
 
   559                 strcmp(qualifier, "SL") == 0) {
 
   548               if (strcmp(qualifier, "SL") == 0) {
 
   560               if (strcmp(qualifier, "SL") == 0) {
 
   549                 print_action_argument(current_action, "reset_remaining_time");  
   561                 print_action_argument(current_action, "reset_remaining_time");
 
   550               }
 
   562               }
 
   551               else {
 
   563               else {
 
   552                 print_action_argument(current_action, "set_remaining_time");
 
   564                 print_action_argument(current_action, "set_remaining_time");
 
   553               }
 
   565               }
 
   554               s4o.print(" = ");
 
   566               s4o.print(" = ");
 
   581     }
 
   593     }
 
   582 
   594 
   583 }; /* generate_c_sfc_actiondecl_c */
 
   595 }; /* generate_c_sfc_actiondecl_c */
 
   584  
   596  
   585  
   597  
   586  
       
   587 /***********************************************************************/
 
   598 /***********************************************************************/
 
   588 /***********************************************************************/
 
   599 /***********************************************************************/
 
   589 /***********************************************************************/
 
   600 /***********************************************************************/
 
   590 /***********************************************************************/
 
   601 /***********************************************************************/
 
   591 
   602 
   592 class generate_c_sfc_c: public generate_c_typedecl_c {
 
   603 class generate_c_sfc_c: public generate_c_typedecl_c {
 
   593   
   604   
   594   private:
 
   605   private:
 
       
   606     std::list<VARIABLE> variable_list;
 
       
   607 
   595     generate_c_sfc_elements_c *generate_c_sfc_elements;
 
   608     generate_c_sfc_elements_c *generate_c_sfc_elements;
 
       
   609     search_var_instance_decl_c *search_var_instance_decl;
 
   596     
   610     
   597   public:
 
   611   public:
 
   598     generate_c_sfc_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL)
 
   612     generate_c_sfc_c(stage4out_c *s4o_ptr, symbol_c *name, symbol_c *scope, const char *variable_prefix = NULL)
 
   599     : generate_c_typedecl_c(s4o_ptr) {
 
   613     : generate_c_typedecl_c(s4o_ptr) {
 
   600       generate_c_sfc_elements = new generate_c_sfc_elements_c(s4o_ptr, scope, variable_prefix);
 
   614       generate_c_sfc_elements = new generate_c_sfc_elements_c(s4o_ptr, name, scope, variable_prefix);
 
       
   615       search_var_instance_decl = new search_var_instance_decl_c(scope);
 
   601       this->set_variable_prefix(variable_prefix);
 
   616       this->set_variable_prefix(variable_prefix);
 
   602     }
 
   617     }
 
   603   
   618   
   604     virtual ~generate_c_sfc_c(void) {
 
   619     virtual ~generate_c_sfc_c(void) {
 
       
   620       variable_list.clear();
 
   605       delete generate_c_sfc_elements;
 
   621       delete generate_c_sfc_elements;
 
       
   622       delete search_var_instance_decl;
 
       
   623     }
 
       
   624 
       
   625     bool is_variable(symbol_c *symbol) {
 
       
   626       /* we try to find the variable instance declaration, to determine if symbol is variable... */
 
       
   627       symbol_c *var_decl = search_var_instance_decl->get_decl(symbol);
 
       
   628 
       
   629       return var_decl != NULL;
 
   606     }
 
   630     }
 
   607 
   631 
   608 /*********************************************/
 
   632 /*********************************************/
 
   609 /* B.1.6  Sequential function chart elements */
 
   633 /* B.1.6  Sequential function chart elements */
 
   610 /*********************************************/
 
   634 /*********************************************/
 
   612     void *visit(sequential_function_chart_c *symbol) {
 
   636     void *visit(sequential_function_chart_c *symbol) {
 
   613       int i;
 
   637       int i;
 
   614       
   638       
   615       generate_c_sfc_elements->reset_transition_number();
 
   639       generate_c_sfc_elements->reset_transition_number();
 
   616       for(i = 0; i < symbol->n; i++) {
 
   640       for(i = 0; i < symbol->n; i++) {
 
       
   641         symbol->elements[i]->accept(*this);
 
   617         generate_c_sfc_elements->generate(symbol->elements[i], generate_c_sfc_elements_c::transitionlist_sg);
 
   642         generate_c_sfc_elements->generate(symbol->elements[i], generate_c_sfc_elements_c::transitionlist_sg);
 
   618       }
 
   643       }
 
   619       
   644       
   620       s4o.print(s4o.indent_spaces +"INT i;\n");
 
   645       s4o.print(s4o.indent_spaces +"INT i;\n");
 
   621       s4o.print(s4o.indent_spaces +"BOOL transition;\n");
 
   646       s4o.print(s4o.indent_spaces +"BOOL transition;\n");
 
   622       s4o.print(s4o.indent_spaces +"TIME elapsed_time, current_time;\n\n");
 
   647       s4o.print(s4o.indent_spaces +"TIME elapsed_time, current_time;\n\n");
 
   623       
   648       
   624       /* generate elapsed_time initialisations */
 
   649       /* generate elapsed_time initializations */
 
   625       s4o.print(s4o.indent_spaces + "// Calculate elapsed_time\n");
 
   650       s4o.print(s4o.indent_spaces + "// Calculate elapsed_time\n");
 
   626       s4o.print(s4o.indent_spaces +"current_time = __CURRENT_TIME;\n");
 
   651       s4o.print(s4o.indent_spaces +"current_time = __CURRENT_TIME;\n");
 
   627       s4o.print(s4o.indent_spaces +"elapsed_time = __time_sub(__BOOL_LITERAL(TRUE), NULL, current_time, ");
 
   652       s4o.print(s4o.indent_spaces +"elapsed_time = __time_sub(__BOOL_LITERAL(TRUE), NULL, current_time, ");
 
   628       print_variable_prefix();
 
   653       print_variable_prefix();
 
   629       s4o.print("__lasttick_time);\n");
 
   654       s4o.print("__lasttick_time);\n");
 
   630       s4o.print(s4o.indent_spaces);
 
   655       s4o.print(s4o.indent_spaces);
 
   631       print_variable_prefix();
 
   656       print_variable_prefix();
 
   632       s4o.print("__lasttick_time = current_time;\n");
 
   657       s4o.print("__lasttick_time = current_time;\n");
 
   633       
   658       
   634       /* generate step initialisations */
 
   659       /* generate transition initializations */
 
   635       s4o.print(s4o.indent_spaces + "// Steps initialisation\n");
 
   660       s4o.print(s4o.indent_spaces + "// Transitions initialization\n");
 
       
   661       s4o.print(s4o.indent_spaces + "if (__DEBUG) {\n");
 
       
   662       s4o.indent_right();
 
   636       s4o.print(s4o.indent_spaces + "for (i = 0; i < ");
 
   663       s4o.print(s4o.indent_spaces + "for (i = 0; i < ");
 
   637       print_variable_prefix();
 
   664       print_variable_prefix();
 
       
   665       s4o.print("__nb_transitions; i++) {\n");
 
       
   666       s4o.indent_right();
 
       
   667       s4o.print(s4o.indent_spaces);
 
       
   668       print_variable_prefix();
 
       
   669       s4o.print("__transition_list[i] = ");
 
       
   670       print_variable_prefix();
 
       
   671       s4o.print("__debug_transition_list[i];\n");
 
       
   672       s4o.indent_left();
 
       
   673       s4o.print(s4o.indent_spaces + "}\n");
 
       
   674       s4o.indent_left();
 
       
   675       s4o.print(s4o.indent_spaces + "}\n");
 
       
   676 
       
   677       /* generate step initializations */
 
       
   678       s4o.print(s4o.indent_spaces + "// Steps initialization\n");
 
       
   679       s4o.print(s4o.indent_spaces + "for (i = 0; i < ");
 
       
   680       print_variable_prefix();
 
   638       s4o.print("__nb_steps; i++) {\n");
 
   681       s4o.print("__nb_steps; i++) {\n");
 
   639       s4o.indent_right();
 
   682       s4o.indent_right();
 
   640       s4o.print(s4o.indent_spaces);
 
   683       s4o.print(s4o.indent_spaces);
 
   641       print_variable_prefix();
 
   684       print_variable_prefix();
 
   642       s4o.print("__step_list[i].prev_state = ");
 
   685       s4o.print("__step_list[i].prev_state = ");
 
   643       print_variable_prefix();
 
   686       s4o.print(GET_VAR);
 
   644       s4o.print("__step_list[i].state;\n");
 
   687       s4o.print("(");
 
       
   688       print_variable_prefix();
 
       
   689       s4o.print("__step_list[i].state);\n");
 
   645       s4o.print(s4o.indent_spaces + "if (");
 
   690       s4o.print(s4o.indent_spaces + "if (");
 
   646       print_variable_prefix();
 
   691       s4o.print(GET_VAR);
 
   647       s4o.print("__step_list[i].state) {\n");
 
   692       s4o.print("(");
 
       
   693       print_variable_prefix();
 
       
   694       s4o.print("__step_list[i].state)) {\n");
 
   648       s4o.indent_right();
 
   695       s4o.indent_right();
 
   649       s4o.print(s4o.indent_spaces);
 
   696       s4o.print(s4o.indent_spaces);
 
   650       print_variable_prefix();
 
   697       print_variable_prefix();
 
   651       s4o.print("__step_list[i].elapsed_time = __time_add(__BOOL_LITERAL(TRUE), NULL, ");
 
   698       s4o.print("__step_list[i].elapsed_time = __time_add(__BOOL_LITERAL(TRUE), NULL, ");
 
   652       print_variable_prefix();
 
   699       print_variable_prefix();
 
   654       s4o.indent_left();
 
   701       s4o.indent_left();
 
   655       s4o.print(s4o.indent_spaces + "}\n");
 
   702       s4o.print(s4o.indent_spaces + "}\n");
 
   656       s4o.indent_left();
 
   703       s4o.indent_left();
 
   657       s4o.print(s4o.indent_spaces + "}\n");
 
   704       s4o.print(s4o.indent_spaces + "}\n");
 
   658 
   705 
   659       /* generate action initilizations */
 
   706       /* generate action initializations */
 
   660       s4o.print(s4o.indent_spaces + "// Actions initialisation\n");
 
   707       s4o.print(s4o.indent_spaces + "// Actions initialization\n");
 
   661       s4o.print(s4o.indent_spaces + "for (i = 0; i < ");
 
   708       s4o.print(s4o.indent_spaces + "for (i = 0; i < ");
 
   662       print_variable_prefix();
 
   709       print_variable_prefix();
 
   663       s4o.print("__nb_actions; i++) {\n");
 
   710       s4o.print("__nb_actions; i++) {\n");
 
   664       s4o.indent_right();
 
   711       s4o.indent_right();
 
   665       s4o.print(s4o.indent_spaces);
 
   712       s4o.print(s4o.indent_spaces);
 
   786       s4o.indent_left();
 
   833       s4o.indent_left();
 
   787       s4o.print(s4o.indent_spaces + "}\n\n");
 
   834       s4o.print(s4o.indent_spaces + "}\n\n");
 
   788       
   835       
   789       /* generate action execution */
 
   836       /* generate action execution */
 
   790       s4o.print(s4o.indent_spaces + "// Actions execution\n");
 
   837       s4o.print(s4o.indent_spaces + "// Actions execution\n");
 
       
   838       {
 
       
   839         std::list<VARIABLE>::iterator pt;
 
       
   840         for(pt = variable_list.begin(); pt != variable_list.end(); pt++) {
 
       
   841           symbol_c *var_decl = search_var_instance_decl->get_decl(pt->symbol);
 
       
   842           if (var_decl != NULL) {
 
       
   843             unsigned int vartype = search_var_instance_decl->get_vartype();
 
       
   844 
       
   845             s4o.print(s4o.indent_spaces);
 
       
   846             if (vartype == search_var_instance_decl_c::external_vt) {
 
       
   847           	  s4o.print(SET_EXTERNAL);
 
       
   848           	  s4o.print("(");
 
       
   849           	  pt->symbol->accept(*this);
 
       
   850               s4o.print(",");
 
       
   851             }
 
       
   852           	else {
 
       
   853           	  if (vartype == search_var_instance_decl_c::located_vt)
 
       
   854           	    s4o.print(SET_LOCATED);
 
       
   855           	  else
 
       
   856           	    s4o.print(SET_VAR);
 
       
   857               s4o.print("(");
 
       
   858           	}
 
       
   859             print_variable_prefix();
 
       
   860             pt->symbol->accept(*this);
 
       
   861             s4o.print(",");
 
       
   862             print_variable_prefix();
 
       
   863             s4o.print("__action_list[");
 
       
   864             s4o.print(SFC_STEP_ACTION_PREFIX);
 
       
   865             pt->symbol->accept(*this);
 
       
   866             s4o.print("].state);\n");
 
       
   867           }
 
       
   868         }
 
       
   869       }
 
   791       for(i = 0; i < symbol->n; i++) {
 
   870       for(i = 0; i < symbol->n; i++) {
 
   792         generate_c_sfc_elements->generate(symbol->elements[i], generate_c_sfc_elements_c::actionbody_sg);
 
   871         generate_c_sfc_elements->generate(symbol->elements[i], generate_c_sfc_elements_c::actionbody_sg);
 
   793       }
 
   872       }
 
   794       s4o.print("\n");
 
   873       s4o.print("\n");
 
   795       
   874       
   796       return NULL;
 
   875       return NULL;
 
   797     }
 
   876     }
 
   798     
   877     
       
   878     void *visit(initial_step_c *symbol) {
 
       
   879       symbol->action_association_list->accept(*this);
 
       
   880       return NULL;
 
       
   881     }
 
       
   882 
       
   883     void *visit(step_c *symbol) {
 
       
   884       symbol->action_association_list->accept(*this);
 
       
   885       return NULL;
 
       
   886     }
 
       
   887 
       
   888     void *visit(action_association_c *symbol) {
 
       
   889       symbol_c *var_decl = search_var_instance_decl->get_decl(symbol->action_name);
 
       
   890 
       
   891       if (var_decl != NULL) {
 
       
   892         std::list<VARIABLE>::iterator pt;
 
       
   893         for(pt = variable_list.begin(); pt != variable_list.end(); pt++) {
 
       
   894           if (!compare_identifiers(pt->symbol, symbol->action_name))
 
       
   895             return NULL;
 
       
   896         }
 
       
   897         VARIABLE *variable;
 
       
   898         variable = new VARIABLE;
 
       
   899         variable->symbol = (identifier_c*)(symbol->action_name);
 
       
   900         variable_list.push_back(*variable);
 
       
   901       }
 
       
   902       return NULL;
 
       
   903     }
 
       
   904 
       
   905     void *visit(transition_c *symbol) {
 
       
   906       return NULL;
 
       
   907     }
 
       
   908 
       
   909     void *visit(action_c *symbol) {
 
       
   910       return NULL;
 
       
   911     }
 
       
   912 
   799     void generate(sequential_function_chart_c *sfc) {
 
   913     void generate(sequential_function_chart_c *sfc) {
 
   800       sfc->accept(*this);
 
   914       sfc->accept(*this);
 
   801     }
 
   915     }
 
   802 
   916 
   803 }; /* generate_c_sfc_c */
 
   917 }; /* generate_c_sfc_c */
matiec