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

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

    21

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

    22

 *

    23

 * Based on the

    24

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

    25

 *

    26

 */

    27

    28

    29

    30

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

    31

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

    32

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

    33

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

    34

    35

class search_location_type_c: public iterator_visitor_c {

    36

    37

  public:

    38

    typedef enum {

    39

      none_lt,

    40

      input_lt,

    41

      output_lt,

    42

      memory_lt

    43

    } locationtype_t;

    44

    45

    locationtype_t current_location_type;

    46

    47

  public:

    48

    search_location_type_c(void) {}

    49

    50

    virtual ~search_location_type_c(void) {}

    51

    52

    locationtype_t get_location_type(symbol_c *symbol) {

    53

      current_location_type = none_lt;

    54

      symbol->accept(*this);

    55

      if (current_location_type == none_lt) ERROR;

    56

      return current_location_type;

    57

    }

    58

    59

  private:

    60

    61

    void *visit(incompl_location_c* symbol) {

    62

      if (symbol->value[1] == 'I')

    63

        current_location_type = input_lt;

    64

     else if (symbol->value[1] == 'Q')

    65

        current_location_type = output_lt;

    66

     else if (symbol->value[1] == 'M')

    67

        current_location_type = memory_lt;

    68

      return NULL;

    69

    }

    70

    71

    void *visit(direct_variable_c *symbol) {

    72

      if (symbol->value[1] == 'I')

    73

        current_location_type = input_lt;

    74

     else if (symbol->value[1] == 'Q')

    75

        current_location_type = output_lt;

    76

     else if (symbol->value[1] == 'M')

    77

        current_location_type = memory_lt;

    78

      return NULL;

    79

    }

    80

};

    81

    82

    83

    84

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

    85

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

    86

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

    87

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

    88

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

    89

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

    90

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

    91

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

    92

    93

/* TODO: Delete this helper class search_type_symbol_c, as well as the search_fb_typedecl_c

    94

 *       in the absyntac_utils directory. They are no longer usefull, now that we have

    95

 *       datatype analysis working!

    96

 */

    97

class search_type_symbol_c: public iterator_visitor_c {

    98

    99

  public:

   100

    typedef enum {

   101

      none_vtc,

   102

      variable_vtc,

   103

      array_vtc,

   104

      structure_vtc,

   105

      function_block_vtc

   106

    } vartypecategory_t;

   107

   108

    vartypecategory_t current_var_type_category;

   109

   110

  private:

   111

    symbol_c *current_var_type_symbol;

   112

    symbol_c *current_var_type_name;

   113

    search_fb_typedecl_c *search_fb_typedecl;

   114

   115

  public:

   116

    search_type_symbol_c(symbol_c *scope) {

   117

      search_fb_typedecl = new search_fb_typedecl_c(scope);

   118

    }

   119

   120

    virtual ~search_type_symbol_c(void) {

   121

      delete search_fb_typedecl;

   122

    }

   123

   124

    symbol_c *get_type_symbol(symbol_c* symbol) {

   125

      this->current_var_type_category = variable_vtc;

   126

      this->current_var_type_symbol = NULL;

   127

      this->current_var_type_name = NULL;

   128

   129

      symbol_c* var_type_symbol = spec_init_sperator_c::get_spec(symbol);

   130

      if (var_type_symbol == NULL) {

   131

        var_type_symbol = symbol;

   132

      }

   133

   134

      var_type_symbol->accept(*this);

   135

   136

      if (this->current_var_type_symbol == NULL)

   137

        this->current_var_type_symbol = var_type_symbol;

   138

   139

      return (this->current_var_type_symbol);

   140

    }

   141

   142

    symbol_c *get_current_type_name(void) {

   143

      if (this->current_var_type_name == NULL)

   144

        return (this->current_var_type_symbol);

   145

   146

      return (this->current_var_type_name);

   147

    }

   148

   149

    void *visit(derived_datatype_identifier_c* symbol) {

   150

      if (this->current_var_type_name == NULL) {

   151

        this->current_var_type_name = symbol;

   152

   153

        this->current_var_type_symbol = search_fb_typedecl->get_decl(this->current_var_type_name);

   154

        if (this->current_var_type_symbol != NULL)

   155

          this->current_var_type_category = function_block_vtc;

   156

   157

        else {

   158

          this->current_var_type_symbol = search_base_type_c::get_basetype_decl(this->current_var_type_name);

   159

          this->current_var_type_symbol->accept(*this);

   160

        }

   161

      }

   162

      return NULL;

   163

    }

   164

   165

    void *visit(poutype_identifier_c* symbol) {

   166

      if (this->current_var_type_name == NULL) {

   167

        this->current_var_type_name = symbol;

   168

   169

        this->current_var_type_symbol = search_fb_typedecl->get_decl(this->current_var_type_name);

   170

        if (this->current_var_type_symbol != NULL)

   171

          this->current_var_type_category = function_block_vtc;

   172

   173

        else {

   174

          this->current_var_type_symbol = search_base_type_c::get_basetype_decl(this->current_var_type_name);

   175

          this->current_var_type_symbol->accept(*this);

   176

        }

   177

      }

   178

      return NULL;

   179

    }

   180

   181

    void *visit(array_specification_c* symbol) {

   182

      this->current_var_type_category = array_vtc;

   183

   184

      if (this->current_var_type_name == NULL)

   185

        this->current_var_type_name = symbol->non_generic_type_name;

   186

   187

      return NULL;

   188

    }

   189

   190

    void *visit(structure_element_declaration_list_c* symbol) {

   191

      this->current_var_type_category = structure_vtc;

   192

      return NULL;

   193

    }

   194

   195

};

   196

   197

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

   198

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

   199

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

   200

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

   201

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

   202

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

   203

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

   204

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

   205

   206

class generate_var_list_c: protected generate_c_base_and_typeid_c {

   207

   208

  public:

   209

    typedef struct {

   210

      symbol_c *symbol;

   211

    } SYMBOL;

   212

   213

    typedef enum {

   214

      none_dt,

   215

      programs_dt,

   216

      variables_dt

   217

    } declarationtype_t;

   218

   219

    declarationtype_t current_declarationtype;

   220

   221

    typedef enum {

   222

      none_vcc,

   223

      external_vcc,

   224

      located_input_vcc,

   225

      located_memory_vcc,

   226

      located_output_vcc

   227

    } varclasscategory_t;

   228

   229

    varclasscategory_t current_var_class_category;

   230

   231

  private:

   232

    symbol_c *current_var_type_symbol;

   233

    symbol_c *current_var_type_name;

   234

    unsigned int current_var_number;

   235

    unsigned int step_number;

   236

    unsigned int transition_number;

   237

    unsigned int action_number;

   238

    bool configuration_defined;

   239

    std::list<SYMBOL> current_symbol_list;

   240

    search_type_symbol_c *search_type_symbol;

   241

   242

  public:

   243

    generate_var_list_c(stage4out_c *s4o_ptr, symbol_c *scope)

   244

    : generate_c_base_and_typeid_c(s4o_ptr) {

   245

      search_type_symbol = new search_type_symbol_c(scope);

   246

      current_var_number = 0;

   247

      current_var_type_symbol = NULL;

   248

      current_var_type_name = NULL;

   249

      current_declarationtype = none_dt;

   250

      current_var_class_category = none_vcc;

   251

    }

   252

   253

    ~generate_var_list_c(void) {

   254

      delete search_type_symbol;

   255

    }

   256

   257

    void update_var_type_symbol(symbol_c *symbol) {

   258

      this->current_var_type_symbol = search_type_symbol->get_type_symbol(symbol);

   259

      this->current_var_type_name = search_type_symbol->get_current_type_name();

   260

    }

   261

   262

    void reset_var_type_symbol(void) {

   263

      this->current_var_type_symbol = NULL;

   264

    }

   265

   266

    void generate_programs(symbol_c *symbol) {

   267

      s4o.print("// Programs\n");

   268

      current_var_number = 0;

   269

      configuration_defined = false;

   270

      current_declarationtype = programs_dt;

   271

      symbol->accept(*this);

   272

      current_declarationtype = none_dt;

   273

      s4o.print("\n");

   274

    }

   275

   276

    void generate_variables(symbol_c *symbol) {

   277

      s4o.print("// Variables\n");

   278

      current_var_number = 0;

   279

      configuration_defined = false;

   280

      current_declarationtype = variables_dt;

   281

      symbol->accept(*this);

   282

      current_declarationtype = none_dt;

   283

      s4o.print("\n");

   284

    }

   285

   286

    void declare_variables(symbol_c *symbol) {

   287

      list_c *list = dynamic_cast<list_c *>(symbol);

   288

      /* should NEVER EVER occur!! */

   289

      if (list == NULL) ERROR;

   290

   291

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

   292

        declare_variable(list->get_element(i));

   293

      }

   294

    }

   295

   296

    void declare_variable(symbol_c *symbol) {

   297

      // Arrays and structures are not supported in debugging

   298

      switch (search_type_symbol->current_var_type_category) {

   299

          case search_type_symbol_c::array_vtc:

   300

          case search_type_symbol_c::structure_vtc:

   301

          return;

   302

          default:

   303

           break;

   304

      }

   305

      print_var_number();

   306

      s4o.print(";");

   307

      switch (search_type_symbol->current_var_type_category) {

   308

        case search_type_symbol_c::array_vtc:

   309

          s4o.print("ARRAY");

   310

          break;

   311

        case search_type_symbol_c::structure_vtc:

   312

          s4o.print("STRUCT");

   313

          break;

   314

        case search_type_symbol_c::function_block_vtc:

   315

          s4o.print("FB");

   316

          break;

   317

        default:

   318

          switch (this->current_var_class_category) {

   319

            case external_vcc:

   320

             s4o.print("EXT");

   321

             break;

   322

            case located_input_vcc:

   323

             s4o.print("IN");

   324

             break;

   325

            case located_memory_vcc:

   326

             s4o.print("MEM");

   327

             break;

   328

            case located_output_vcc:

   329

             s4o.print("OUT");

   330

             break;

   331

            default:

   332

             s4o.print("VAR");

   333

             break;

   334

          }

   335

          break;

   336

      }

   337

      s4o.print(";");

   338

      print_symbol_list();

   339

      symbol->accept(*this);

   340

      s4o.print(";");

   341

      print_symbol_list();

   342

      symbol->accept(*this);

   343

      s4o.print(";");

   344

      switch (search_type_symbol->current_var_type_category) {

   345

        case search_type_symbol_c::structure_vtc:

   346

        case search_type_symbol_c::function_block_vtc:

   347

          this->current_var_type_name->accept(*this);

   349

          if (this->current_var_class_category != external_vcc) {

   350

              SYMBOL *current_name;

   351

              symbol_c *tmp_var_type;

   352

              current_name = new SYMBOL;

   353

              current_name->symbol = symbol;

   354

              tmp_var_type = this->current_var_type_symbol;

   355

              current_symbol_list.push_back(*current_name);

   356

              this->current_var_type_symbol->accept(*this);

   357

              current_symbol_list.pop_back();

   358

              this->current_var_type_symbol = tmp_var_type;

   359

          }

   360

          break;

   361

        case search_type_symbol_c::array_vtc:

   362

          this->current_var_type_name->accept(*this);

   364

          break;

   365

        default:

   367

          this->current_var_type_symbol->accept(*this);

   371

          s4o.print(";\n");

   372

          break;

   373

      }

   374

    }

   375

   376

    void print_var_number(void) {

   377

      char str[10];

   378

      sprintf(str, "%d", current_var_number);

   379

      s4o.print(str);

   380

      current_var_number++;

   381

    }

   382

   383

    void print_step_number(void) {

   384

      char str[10];

   385

      sprintf(str, "%d", step_number);

   386

      s4o.print(str);

   387

    }

   388

   389

    void print_transition_number(void) {

   390

      char str[10];

   391

      sprintf(str, "%d", transition_number);

   392

      s4o.print(str);

   393

    }

   394

   395

    void print_action_number(void) {

   396

      char str[10];

   397

      sprintf(str, "%d", action_number);

   398

      s4o.print(str);

   399

    }

   400

   401

    void print_symbol_list() {

   402

      std::list<SYMBOL>::iterator pt;

   403

      for(pt = current_symbol_list.begin(); pt != current_symbol_list.end(); pt++) {

   404

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

   405

        s4o.print(".");

   406

      }

   407

    }

   408

   409

   410

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

   411

/* B 1.3.3 - Derived data types */

   412

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

   413

    /*  enumerated_type_name ':' enumerated_spec_init */

   414

    void *visit(enumerated_type_declaration_c *symbol) {

   415

      this->current_var_type_name->accept(*this);

   416

      return NULL;

   417

    }

   418

   419

    /* enumerated_specification ASSIGN enumerated_value */

   420

    void *visit(enumerated_spec_init_c *symbol) {

   421

      /* search_base_type_c now returns an enumerated_type_declaration_c as the base type of a non-anonymous enumerated type

   422

       * (non-anonymous means it is declared inside a TYPE ... END_TYPE declaration, with a given name/identifier

   423

       *  unlike implicitly defined anonymous datatypes declared inside VAR ... END_VAR declarations!).

   424

       * This means that this method should not get called.

   425

       */

   426

      ERROR;  

   427

      this->current_var_type_name->accept(*this);

   428

      return NULL;

   429

    }

   430

   431

    /* enumerated_value_list ',' enumerated_value */

   432

    void *visit(enumerated_value_list_c *symbol) {

   433

      /* search_base_type_c now returns an enumerated_type_declaration_c as the base type of a non-anonymous enumerated type

   434

       * (non-anonymous means it is declared inside a TYPE ... END_TYPE declaration, with a given name/identifier

   435

       *  unlike implicitly defined anonymous datatypes declared inside VAR ... END_VAR declarations!).

   436

       * This means that this method should not get called.

   437

       */

   438

      ERROR;

   439

      this->current_var_type_name->accept(*this);

   440

      return NULL;

   441

    }

   442

   443

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

   444

/* B.1.4.3 - Declaration and initialization */

   445

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

   446

   447

    /*  [variable_name] location ':' located_var_spec_init */

   448

    /* variable_name -> may be NULL ! */

   449

    //SYM_REF4(located_var_decl_c, variable_name, location, located_var_spec_init, unused)

   450

    void *visit(located_var_decl_c *symbol) {

   451

        /* Start off by setting the current_var_type_symbol and

   452

         * current_var_init_symbol private variables...

   453

         */

   454

        update_var_type_symbol(symbol->located_var_spec_init);

   455

   456

        search_location_type_c search_location_type;

   457

        switch (search_location_type.get_location_type(symbol->location)) {

   458

          case search_location_type_c::input_lt:

   459

            this->current_var_class_category = located_input_vcc;

   460

            break;

   461

          case search_location_type_c::memory_lt:

   462

            this->current_var_class_category = located_memory_vcc;

   463

            break;

   464

          case search_location_type_c::output_lt:

   465

              this->current_var_class_category = located_output_vcc;

   466

              break;

   467

          default:

   468

            ERROR;

   469

            break;

   470

        }

   471

   472

        if (symbol->variable_name != NULL)

   473

          declare_variable(symbol->variable_name);

   474

        else

   475

          declare_variable(symbol->location);

   476

   477

        this->current_var_class_category = none_vcc;

   478

   479

        /* Values no longer in scope, and therefore no longer used.

   480

         * Make an effort to keep them set to NULL when not in use

   481

         * in order to catch bugs as soon as possible...

   482

         */

   483

        reset_var_type_symbol();

   484

        return NULL;

   485

    }

   486

   487

    /* variable_name incompl_location ':' var_spec */

   488

    /* variable_name -> may be NULL ! */

   489

    //SYM_REF3(incompl_located_var_decl_c, variable_name, incompl_location, var_spec)

   490

    void *visit(incompl_located_var_decl_c *symbol) {

   491

        /* Start off by setting the current_var_type_symbol and

   492

         * current_var_init_symbol private variables...

   493

         */

   494

        update_var_type_symbol(symbol->var_spec);