1

/*

     2

 * (c) 2003 Mario de Sousa

     3

 *

     4

 * Offered to the public under the terms of the GNU General Public License

     5

 * as published by the Free Software Foundation; either version 2 of the

     6

 * License, or (at your option) any later version.

     7

 *

     8

 * This program is distributed in the hope that it will be useful, but

     9

 * WITHOUT ANY WARRANTY; without even the implied warranty of

    10

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General

    11

 * Public License for more details.

    12

 *

    13

 * This code is made available on the understanding that it will not be

    14

 * used in safety-critical situations without a full and competent review.

    15

 */

    16

    17

/*

    18

 * An IEC 61131-3 IL and ST compiler.

    19

 *

    20

 * Based on the

    21

 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    22

 *

    23

 */

    24

    25

    26

/*

    27

 * Declare temporary variables to be later used as output parameters

    28

 * in function calls for which not all output parameters were

    29

 * defined in the original (st or il) source code.

    30

 *

    31

 * This is part of the 4th stage that generates

    32

 * a c++ source program equivalent to the IL and ST

    33

 * code.

    34

 */

    35

    36

    37

    38

    39

class temp_var_name_c {

    40

  private:

    41

    int counter;

    42

    43

  public:

    44

    void reset(void) {counter = 0;}

    45

    temp_var_name_c(void) {reset();}

    46

    47

  public:

    48

    std::string *new_name(void) {

    49

      std::string *new_str = new std::string(TEMP_VAR);

    50

      /* yikes!!! How to convert an int to a string elegantly???

    51

       * Right now I (Mario) can only think of snprintf()

    52

       * C++ must have a more elegant method!

    53

       */

    54

      int int_str_size = snprintf(NULL, 0, "%d", counter);

    55

      if (int_str_size <= 0) ERROR;

    56

      char *int_str = (char *)malloc(int_str_size+1);

    57

      if (snprintf(int_str, int_str_size+1, "%d", counter++) >= int_str_size+1) ERROR;

    58

      *new_str += int_str;

    59

      free(int_str);

    60

      return new_str;

    61

    }

    62

    63

};

    64

    65

    66

    67

/***********************************************************************/

    68

/***********************************************************************/

    69

/***********************************************************************/

    70

/***********************************************************************/

    71

    72

    73

    74

/* Some function calls in the body of functions or function blocks

    75

 * may leave some parameters to their default values, and

    76

 * ignore some output parameters of the function being called.

    77

 * Our conversion of ST functions to C++ does not contemplate that,

    78

 * i.e. each called function must get all it's input and output

    79

 * parameters set correctly.

    80

 * For input parameters we merely need to call the function with

    81

 * the apropriate default value, but for output parameters

    82

 * we must create temporary variables to hold the output value.

    83

 *

    84

 * We declare all the temporary output variables at the begining of

    85

 * the body of each function or function block, and use them as

    86

 * in function calls later on as they become necessary...

    87

 * Note that we cannot create these variables just before a function

    88

 * call, as the function call itself may be integrated within an

    89

 * expression, or another function call!

    90

 *

    91

 * The variables are declared in the exact same order in which they

    92

 * will be used later on during the function calls, which allows us

    93

 * to simply re-create the name that was used for the temporary variable

    94

 * instead of keeping it in some list.

    95

 * The names are recreated by the temp_var_name_factory, after reset()

    96

 * has been called!

    97

 *

    98

 * This function will genertae code similar to...

    99

 *

   100

 *     INT __TMP_0 = 23;

   101

 *     REAL __TMP_1 = 45.5;

   102

 *     ...

   103

 */

   104

   105

class generate_cc_tempvardecl_c: generate_cc_typedecl_c {

   106

  public:

   107

    generate_cc_tempvardecl_c(stage4out_c *s4o_ptr): generate_cc_typedecl_c(s4o_ptr) {}

   108

   109

    void generate(symbol_c *body, temp_var_name_c *temp_var_name_factory) {

   110

      temp_var_name_factory->reset();

   111

      function_call_iterator_c fcall_iterator(body);

   112

      for(symbol_c *finvocation = NULL; (finvocation = fcall_iterator.next()) != NULL;) {

   113

        /* get the name of the next function that gets called */

   114

        identifier_c *fcalled_name = fcall_iterator.fname();

   115

        /* get that function's declaration... */

   116

        function_declaration_c *fdecl = function_symtable.find_value(fcalled_name);

   117

        if (fdecl == function_symtable.end_value()) ERROR;

   118

        /* create iterator to iterate through each of the called function's parameters... */

   119

        function_param_iterator_c fp_iterator(fdecl);

   120

   121

        /* iterate through each of the called function's parameters... */

   122

        identifier_c *param_name = NULL;

   123

        function_call_param_iterator_c function_call_param_iterator(finvocation);

   124

        for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {

   125

   126

          function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();

   127

          if (param_direction == function_param_iterator_c::direction_in)

   128

            /* ignore input only parameters...

   129

             * we do not need to create temporary variables for these!

   130

             */

   131

            continue;

   132

   133

          /* Get the value from a foo(<param_name> = <param_value>) style call */

   134

          symbol_c *param_value = function_call_param_iterator.search(param_name);

   135

   136

          /* Get the value from a foo(<param_value>) style call */

   137

          if (param_value == NULL)

   138

            param_value = function_call_param_iterator.next();

   139

   140

          if (param_value != NULL)

   141

            /* ignore output parameters to which a variable is passed...

   142

             * we do not need to create temporary variables for these!

   143

             */

   144

            continue;

   145

   146

          symbol_c *param_type = fp_iterator.param_type();

   147

   148

          /* get the parameter's default value */

   149

          param_value = fp_iterator.default_value();

   150

   151

          /* If no default value specified in function declaration,

   152

           * get the default value of this variable's type

   153

           */

   154

          if (param_value == NULL)

   155

            param_value = (symbol_c *)param_type->accept(*type_initial_value_c::instance());

   156

          if (param_value == NULL) ERROR;

   157

   158

          /* now declare a temporary variable, with the correct default value... */

   159

          s4o.print(s4o.indent_spaces);

   160

          param_type->accept(*this);

   161

          s4o.print(" ");

   162

   163

          std::string *temp_var_name = temp_var_name_factory->new_name();

   164

          s4o.print(*temp_var_name);

   165

          delete temp_var_name;

   166

   167

          s4o.print(" = ");

   168

          param_value->accept(*this);

   169

          s4o.print(";\n");

   170

        }

   171

      }

   172

      temp_var_name_factory->reset();

   173

      s4o.print("\n");

   174

    }

   175

};