26

    27

/* Ths class contains two main classes:

    28

 *    - generate_c_typedecl_c

    29

 *    - generate_c_implicit_typedecl_c

    30

 * 

    31

 * and an auxiliary class

    32

 *    - generate_datatypes_aliasid_c

    33

 * 

    34

 * 

    35

 * Both the generate_c_typedecl_c and the generate_c_implicit_typedecl_c may set a stage4

    36

 * annotation (in the stage4 annotation map of each symbol_c) named 

    37

 *   "generate_c_annotaton__implicit_type_id"

    38

 * If this annotation is set, the generate_c_base_c will print out this value instead of 

    39

 * the datatype's name!

    40

 * 

    41

 * 

    42

 * 

    43

 * generate_c_typedecl_c

    44

 * ---------------------

    45

 *   Given a datatype object (i.e. an object in the AST that is also used to define a datatype,

    46

 *    typically one that may be returned by search_basetype_c), this class will generate the 

    47

 *    C code to declare an equivakent datatype in C.

    48

 *   Note that array datatypes are handled in a special way; instead of using the name given

    49

 *    to it in the IEC 61131-3 source code, and new alias is created for the datatype name in C.

    50

 *    Eplanations why we do this may be found further on...

    51

 * 

    52

 * 

    53

 * generate_c_implicit_typedecl_c

    54

 * ------------------------------

    55

 *   Given a POU or a derived datatype declaration, it will search for any implicitly defined 

    56

 *    datatypes in that POU/datatype declaration. Implicit datatypes are datatypes that are not 

    57

 *    explicitly declared and given a name. Example:

    58

 *       VAR a: ARRAY [9..11] of INT; END_VAR

    59

 *    Here, the array is implictly delcared.

    60

 *    For eac implicitly defined datatype, an alias for that datatype is created (by calling

    61

 *    generate_datatypes_aliasid_c), and a C declaration is generated in C source code (by

    62

 *    calling generate_c_typedecl_c).

    63

 * 

    64

 * 

    65

 * generate_datatypes_aliasid_c

    66

 * ----------------------------

    67

 *   Given a datatype object (i.e. an object in the AST that defines a datatype), it will create

    68

 *    an alias name for that datatype.

    69

 *    This class is used by both the generate_c_implicit_typedecl_c, and the generate_c_typedecl_c

    70

 *    classes!

    71

 */

    72

    73

    74

    75

    76

    77

    78

/* generate an alias/name (identifier) for array and REF_TO datatypes */

    79

/*

    80

 *  The generated alias is created based on the structure of the datatype itself, in order to

    81

 *  guarantee that any two datatypes that have the same internal format will result in the same

    82

 *  alias.

    83

 *   examples:

    84

 *      ARRAY [9..11] of INT        --> __ARRAY_9_11_OF_INT

    85

 *      REF_TO INT                  --> __REF_TO_INT

    86

 *      ARRAY [9..11] of REF_TO INT --> __ARRAY_9_11_OF___REF_TO_INT

    87

 */

    88

class generate_datatypes_aliasid_c: fcall_visitor_c {

    89

    90

  private:

    91

    //std::map<std::string, int> inline_array_defined;

    92

    std::string current_array_name;

    93

    static generate_datatypes_aliasid_c *singleton_;

    94

    95

  public:

    96

    generate_datatypes_aliasid_c(void) {};

    97

    98

    virtual ~generate_datatypes_aliasid_c(void) {

    99

      //inline_array_defined.clear(); // Not really necessary...

   100

    }

   101

   102

    /* implement the virtual member function declared in fcall_visitor_c */

   103

    // by default generate an ERROR if a visit method is called, unless it is explicitly handled in generate_datatypes_aliasid_c

   104

    void fcall(symbol_c *symbol) {ERROR;} 

   105

   106

    static identifier_c *create_id(symbol_c *symbol) {

   107

      if (NULL == singleton_) singleton_ = new generate_datatypes_aliasid_c();

   108

      if (NULL == singleton_) ERROR;

   109

      singleton_->current_array_name = "";

   110

      symbol->accept(*singleton_);

   111

      const char *str1 = singleton_->current_array_name.c_str();

   112

      char       *str2 = (char *)malloc(strlen(str1)+1);

   113

      if (NULL == str2) ERROR;

   114

      strcpy(str2, str1);

   115

      identifier_c *id = new identifier_c(str2);

   116

      /* Copy all the anotations in the symbol_c object 'symbol' to the newly created 'id' object

   117

       *   This includes the location (in the IEC 61131-3 source file) annotations set in stage1_2,

   118

       *   the symbol->datatype set in stage3, and any other anotaions that may be created in the future!

   119

       */

   120

      *(dynamic_cast<symbol_c *>(id)) = *(dynamic_cast<symbol_c *>(symbol));

   121

      return id;

   122

    }

   123

   124

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

   125

    /* B.1 - Common elements */

   126

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

   127

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

   128

    /* B.1.3 - Data types */

   129

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

   130

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

   131

    /* B 1.3.1 - Elementary Data Types */

   132

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

   133

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

   134

    /* B 1.3.2 - Generic Data Types    */

   135

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

   136

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

   137

    /* B 1.3.3 - Derived data types */

   138

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

   139

    /* ref_spec:  REF_TO (non_generic_type_name | function_block_type_name) */

   140

    void *visit(ref_spec_c *symbol) {

   141

      current_array_name = "__REF_TO_";

   142

      current_array_name += get_datatype_info_c::get_id_str(symbol->type_name);

   143

      return NULL;

   144

    }

   145

   146

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

   147

    /* B 1.4.3 - Declaration & Initialization */

   148

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

   149

    /* array_specification [ASSIGN array_initialization] */

   150

    /* array_initialization may be NULL ! */

   151

    void *visit(array_spec_init_c *symbol) {

   152

      if (NULL == symbol->datatype) ERROR;

   153

      symbol->datatype->accept(*this); // the base datatype should be an array_specification_c !!

   154

      return NULL;

   155

    }

   156

   157

    /* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */

   158

    void *visit(array_specification_c *symbol) {

   159

      current_array_name = "__ARRAY_OF_";

   160

      if (    get_datatype_info_c::is_ref_to(symbol->non_generic_type_name)

   161

          && (get_datatype_info_c::get_ref_to(symbol->non_generic_type_name) != NULL)) {

   162

        /* handle situations where we have 2 impliclitly defined datatype, namely a REF_TO inside an ARRAY

   163

         *    e.g. TYPE array_of_ref_to_sint : ARRAY [1..3] OF  REF_TO  SINT; END_TYPE

   164

         * The second condition (get_datatype_info_c::get_ref_to(symbol->non_generic_type_name) != NULL)

   165

         * in the above if() is to make sure we use the standard algorithm if the array is of a previously 

   166

         * defined REF_TO type, in which case symbol->non_generic_type_name will reference an identifier_c!

   167

         *    e.g. TYPE array_of_ref_to_sint : ARRAY [1..3] OF  REF_TO  SINT; END_TYPE

   168

         */

   169

        current_array_name += "__REF_TO_";

   170

        current_array_name += get_datatype_info_c::get_id_str(get_datatype_info_c::get_ref_to(symbol->non_generic_type_name));

   171

      } else {

   172

        current_array_name += get_datatype_info_c::get_id_str(symbol->non_generic_type_name);

   173

      }

   174

      symbol->array_subrange_list->accept(*this);

   175

      return NULL;

   176

    }

   177

   178

    /* helper symbol for array_specification */

   179

    /* array_subrange_list ',' subrange */

   180

    void *visit(array_subrange_list_c *symbol) {

   181

      for(int i = 0; i < symbol->n; i++) {symbol->elements[i]->accept(*this);}

   182

      return NULL;

   183

    }

   184

   185

    /*  signed_integer DOTDOT signed_integer */

   186

    //SYM_REF2(subrange_c, lower_limit, upper_limit)

   187

    void *visit(subrange_c *symbol) {

   188

      current_array_name += "_";

   189

      std::stringstream ss;

   190

      ss << symbol->dimension;

   191

      current_array_name += ss.str();

   192

      return NULL;

   193

    }

   194

   195

   196

};

   197

   198

   199

generate_datatypes_aliasid_c *generate_datatypes_aliasid_c::singleton_ = NULL;

   200

   201

   202

   203

   204

   205

   206

   207

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

   208

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

   209

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

   210

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

   211

   212

/* Given an object in the AST that defines a datatype, generate the C source code that declares an

   213

 * equivalent dataype in C.

   214

 * WARNING: This class maintains internal state in the datatypes_already_defined map.

   215

 *          Using multiple isntances of this class may result in different C source code

   216

 *          compared to when a single instance of this class is used for all datatype declarations!

   217

 * 

   218

 * Except for arrays, the C datatype will have the same name as the name of the datatype in the

   219

 * IEC 61131-3 source code.

   220

 * For arrays an alias is created for each datatype. This alias has the property of being equal

   221

 * for arrays with the same internal structure.

   222

 * 

   223

 * Example:

   224

 *  TYPE

   225

 *      array1: ARRAY [9..11] of INT;

   226

 *      array2: ARRAY [9..11] of INT;

   227

 *  END_TYPE

   228

 * 

   229

 * will result in both arrays having the same name (__ARRAY_9_11_OF_INT) in the C source code.

   230

 * 

   231

 * A single C datatype declaration will be generated for both arrays

   232

 *  (the datatypes_already_defined keeps track of which datatypes have already been declared in C)

   233

 * This method of handling arrays is needed when the relaxed datatype model is used 

   234

 * (see get_datatype_info_c for explanation on the relaxed datatype model).

   235

 */

   236

/* Notice that this class inherits from generate_c_base_c, and not from generate_c_base_and_typeid_c.

   237

 * This is intentional! 

   238

 * Whenever this class needs to print out the id of a datatype, it will explicitly use a private instance

   239

 * (generate_c_typeid) of generate_c_base_and_typeid_c!

   240

 */

   248

    generate_c_base_and_typeid_c *generate_c_typeid;

   249

    std::map<std::string, int> datatypes_already_defined;

   250

   252

    generate_c_typedecl_c(stage4out_c *s4o_ptr): generate_c_base_c(s4o_ptr), s4o_incl(*s4o_ptr) /*, generate_c_print_typename(s4o_ptr) */{

   256

      generate_c_typeid = new generate_c_base_and_typeid_c(&s4o_incl);

   259

      delete generate_c_typeid;

   368

  current_type_name->accept(*generate_c_typeid);

   398

        symbol->integer_type_name->accept(*generate_c_typeid);

   403

          current_type_name->accept(*generate_c_typeid);

   405

          current_type_name->accept(*generate_c_typeid);

   407

          current_type_name->accept(*generate_c_typeid);

   431

          current_type_name->accept(*generate_c_typeid);

   433

          symbol->integer_type_name->accept(*generate_c_typeid);

   461

      symbol->lower_limit->accept(*generate_c_typeid);

   465

      symbol->lower_limit->accept(*generate_c_typeid);

   469

      symbol->upper_limit->accept(*generate_c_typeid);

   473

      symbol->upper_limit->accept(*generate_c_typeid);

   494

  current_type_name->accept(*generate_c_typeid);