1

/*

     2

 *  matiec - a compiler for the programming languages defined in IEC 61131-3

     3

 *

     4

 *  Copyright (C) 2003-2011  Mario de Sousa (msousa@fe.up.pt)

     5

 *  Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant

     6

 *

     7

 *  This program is free software: you can redistribute it and/or modify

     8

 *  it under the terms of the GNU General Public License as published by

     9

 *  the Free Software Foundation, either version 3 of the License, or

    10

 *  (at your option) any later version.

    11

 *

    12

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

    13

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    14

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    15

 *  GNU General Public License for more details.

    16

 *

    17

 *  You should have received a copy of the GNU General Public License

    18

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

    19

 *

    20

 *

    21

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

    22

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

    23

 */

    24

#include <stdlib.h>

    25

    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->get_element(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

/* The generate_c_typedecl_c inherits from generate_c_base_and_typeid_c because it will need the visitor's() to

   237

 *   identifier_c, derived_datatype_identifier_c, and enumerated_value_c

   238

 */

   239

class generate_c_typedecl_c: public generate_c_base_and_typeid_c {

   240

   241

  protected:

   242

    /* The following member variable is completely useless - the s4o variable inherited from generate_c_base_and_typeid_c

   243

     * could be used to the same effect. We keep it here merely because this generate_c_typedecl_c will typically be called

   244

     * with s4o referencing an include file (typically POUS.h), and using s4o_incl throughout this code will help the reader

   245

     * of the code to keep this fact in mind.

   246

     */

   247

    stage4out_c &s4o_incl;

   248

   249

  private:

   250

    symbol_c* current_type_name;

   251

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

   252

    /* Although this generate_c_typedecl_c inherits directly from generate_c_base_and_typeid_c, we still need an independent

   253

     * instance of that base class. This is because generate_c_typedecl_c will overload some of the visitors in the base class

   254

     * generate_c_base_and_typeid_c.

   255

     *  When we want the to use the version of these visitors() in generate_c_typedecl_c,        we call accept(*this);

   256

     *  When we want the to use the version of these visitors() in generate_c_base_and_typeid_c, we call accept(*generate_c_typeid);

   257

     */

   258

    generate_c_base_and_typeid_c *generate_c_typeid;

   259

   260

   261

  public:

   262

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

   263

      current_typedefinition = none_td;

   264

      current_basetypedeclaration = none_bd;

   265

      current_type_name = NULL;

   266

      generate_c_typeid = new generate_c_base_and_typeid_c(&s4o_incl);

   267

    }

   268

    ~generate_c_typedecl_c(void) {

   269

      delete generate_c_typeid;

   270

    }

   271

   272

    typedef enum {

   273

      none_td,

   274

      enumerated_td,

   275

      subrange_td,

   276

      array_td,

   277

      struct_td

   278

    } typedefinition_t;

   279

   280

    typedefinition_t current_typedefinition;

   281

   282

    typedef enum {

   283

      none_bd,

   284

      subrangebasetype_bd,

   285

      subrangetest_bd,

   286

      arraysubrange_bd

   287

    } basetypedeclaration_t;

   288

   289

    basetypedeclaration_t current_basetypedeclaration;

   290

   291

    void *print_list_incl(list_c *list,

   292

         std::string pre_elem_str = "",

   293

         std::string inter_elem_str = "",

   294

         std::string post_elem_str = "") {

   295

   296

      if (list->n > 0) {

   297

        s4o_incl.print(pre_elem_str);

   298

        list->get_element(0)->accept(*this);

   299

      }

   300

   301

      for(int i = 1; i < list->n; i++) {

   302

        s4o_incl.print(inter_elem_str);

   303

        list->get_element(i)->accept(*this);

   304

      }

   305

   306

      if (list->n > 0)

   307

        s4o_incl.print(post_elem_str);

   308

   309

      return NULL;

   310

    }

   311

   312

   313

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

   314

/* B 0 - Programming Model */

   315

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

   316

  /* leave for derived classes... */

   317

   318

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

   319

/* B.1 - Common elements */

   320

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

   321

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

   322

/* B 1.1 - Letters, digits and identifiers */

   323

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

   324

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

   325

/* B 1.2 - Constants */

   326

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

   327

  /* originally empty... */

   328

   329

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

   330

/* B 1.2.1 - Numeric Literals */

   331

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

   332

  /* done in base class(es) */

   333

   334

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

   335

/* B.1.2.2   Character Strings */

   336

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

   337

  /* done in base class(es) */

   338

   339

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

   340

/* B 1.2.3 - Time Literals */

   341

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

   342

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

   343

/* B 1.2.3.1 - Duration */

   344

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

   345

  /* done in base class(es) */

   346

   347

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

   348

/* B 1.2.3.2 - Time of day and Date */

   349

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

   350

  /* done in base class(es) */

   351

   352

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

   353

/* B.1.3 - Data types */

   354

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

   355

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

   356

/* B 1.3.1 - Elementary Data Types */

   357

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

   358

  /* done in base class(es) */

   359

   360

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

   361

/* B.1.3.2 - Generic data types */

   362

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

   363

  /* originally empty... */

   364

   365

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

   366

/* B 1.3.3 - Derived data types */

   367

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

   368

/*  subrange_type_name ':' subrange_spec_init */

   369

void *visit(subrange_type_declaration_c *symbol) {

   370

  TRACE("subrange_type_declaration_c");  

   371

   372

  current_typedefinition = subrange_td;

   373

  current_type_name = symbol->subrange_type_name;

   374

   375

  s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   376

  current_type_name->accept(*generate_c_typeid);

   377

  s4o_incl.print(",");

   378

  current_basetypedeclaration = subrangebasetype_bd;

   379

  symbol->subrange_spec_init->accept(*this); // always calls subrange_spec_init_c

   380

  current_basetypedeclaration = none_bd;

   381

  s4o_incl.print(")\n");

   382

   383

  current_basetypedeclaration = subrangetest_bd;

   384

  symbol->subrange_spec_init->accept(*this); // always calls subrange_spec_init_c

   385

  current_basetypedeclaration = none_bd;

   386

   387

  current_type_name = NULL;

   388

  current_typedefinition = none_td;

   389

   390

  return NULL;

   391

}

   392

   393

/* subrange_specification ASSIGN signed_integer */

   394

void *visit(subrange_spec_init_c *symbol) {

   395

  TRACE("subrange_spec_init_c");

   396

  symbol->subrange_specification->accept(*this); // always calls subrange_specification_c

   397

  return NULL;

   398

}

   399

   400

/*  integer_type_name '(' subrange')' */

   401

void *visit(subrange_specification_c *symbol) {

   402

  TRACE("subrange_specification_c");

   403

  if (current_typedefinition == subrange_td) {

   404

    switch (current_basetypedeclaration) {

   405

      case subrangebasetype_bd:

   406

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

   407

        break;

   408

      case subrangetest_bd:

   409

        if (symbol->subrange != NULL) {

   410

          s4o_incl.print("static inline ");

   411

          current_type_name->accept(*generate_c_typeid);

   412

          s4o_incl.print(" __CHECK_");

   413

          current_type_name->accept(*generate_c_typeid);

   414

          s4o_incl.print("(");

   415

          current_type_name->accept(*generate_c_typeid);

   416

          s4o_incl.print(" value) {\n");

   417

          s4o_incl.indent_right();

   418

   419

          /* NOTE: IEC 61131-3 v2 syntax mandates that the integer type name be one of SINT, ..., LINT, USINT, ... ULIT */

   420

          /*       For this reason, the following condition will always be false, and therefore this is a block

   421

           *       of dead code. However, let's not delete it for now. It might come in useful for IEC 61131-3 v3.

   422

           *       For the moment, we just comment it out!

   423

           */

   424

          /*

   425

          if (get_datatype_info_c::is_subrange(symbol->integer_type_name)) {

   426

            s4o_incl.print(s4o_incl.indent_spaces + "value = __CHECK_");

   427

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

   428

            s4o_incl.print("(value);\n");

   429

          }

   430

          */

   431

   432

          symbol->subrange->accept(*this); // always calls subrange_c

   433

   434

          s4o_incl.indent_left();

   435

          s4o_incl.print("}\n");

   436

        }

   437

        else {

   438

          s4o_incl.print("#define __CHECK_");

   439

          current_type_name->accept(*generate_c_typeid);

   440

          s4o_incl.print(" __CHECK_");

   441

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

   442

          s4o_incl.print("\n");

   443

        }

   444

        break;

   445

      default:

   446

        break;

   447

    }

   448

  }

   449

  return NULL;

   450

}

   451

   452

   453

/*  signed_integer DOTDOT signed_integer */

   454

void *visit(subrange_c *symbol) {

   455

  TRACE("subrange_c");

   456

  int dimension;

   457

  switch (current_typedefinition) {

   458

    case array_td:

   459

      if (current_basetypedeclaration == arraysubrange_bd) {

   460

        s4o_incl.print("[");

   461

        s4o_incl.print(symbol->dimension);

   462

        s4o_incl.print("]");

   463

      }

   464

      else

   465

        symbol->lower_limit->accept(*this);  // always calls neg_integer_c or integer_c

   466

      break;

   467

    case subrange_td:

   468

      s4o_incl.print(s4o_incl.indent_spaces + "if (value < ");

   469

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

   470

      s4o_incl.print(")\n");

   471

      s4o_incl.indent_right();

   472

      s4o_incl.print(s4o_incl.indent_spaces + "return ");

   473

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

   474

      s4o_incl.print(";\n");

   475

      s4o_incl.indent_left();

   476

      s4o_incl.print(s4o_incl.indent_spaces + "else if (value > ");

   477

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

   478

      s4o_incl.print(")\n");

   479

      s4o_incl.indent_right();

   480

      s4o_incl.print(s4o_incl.indent_spaces + "return ");

   481

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

   482

      s4o_incl.print(";\n");

   483

      s4o_incl.indent_left();

   484

      s4o_incl.print(s4o_incl.indent_spaces + "else\n");

   485

      s4o_incl.indent_right();

   486

      s4o_incl.print(s4o_incl.indent_spaces + "return value;\n");

   487

      s4o_incl.indent_left();

   488

    default:

   489

      break;

   490

  }

   491

  return NULL;

   492

}

   493