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

    94

class search_type_symbol_c: public iterator_visitor_c {

    95

    96

  public:

    97

    typedef enum {

    98

      none_vtc,

    99

      variable_vtc,

   100

      array_vtc,

   101

      structure_vtc,

   102

      function_block_vtc

   103

    } vartypecategory_t;

   104

   105

    vartypecategory_t current_var_type_category;

   106

   107

  private:

   108

    symbol_c *current_var_type_symbol;

   109

    symbol_c *current_var_type_name;

   110

    search_base_type_c search_base_type;

   111

    search_fb_typedecl_c *search_fb_typedecl;

   112

   113

  public:

   114

    search_type_symbol_c(symbol_c *scope) {

   115

      search_fb_typedecl = new search_fb_typedecl_c(scope);

   116

    }

   117

   118

    virtual ~search_type_symbol_c(void) {

   119

      delete search_fb_typedecl;

   120

    }

   121

   122

    symbol_c *get_type_symbol(symbol_c* symbol) {

   123

      this->current_var_type_category = variable_vtc;

   124

      this->current_var_type_symbol = NULL;

   125

      this->current_var_type_name = NULL;

   126

   127

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

   128

      if (var_type_symbol == NULL) {

   129

        var_type_symbol = symbol;

   130

      }

   131

   132

      var_type_symbol->accept(*this);

   133

   134

      if (this->current_var_type_symbol == NULL)

   135

    	this->current_var_type_symbol = var_type_symbol;

   136

   137

      return (this->current_var_type_symbol);

   138

    }

   139

   140

    symbol_c *get_current_type_name(void) {

   141

      if (this->current_var_type_name == NULL)

   142

    	return (this->current_var_type_symbol);

   143

   144

      return (this->current_var_type_name);

   145

    }

   146

   147

    void *visit(identifier_c* symbol) {

   148

      if (this->current_var_type_name == NULL) {

   149

        this->current_var_type_name = symbol;

   150

   151

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

   152

        if (this->current_var_type_symbol != NULL)

   153

          this->current_var_type_category = function_block_vtc;

   154

   155

        else {

   156

          this->current_var_type_symbol = (symbol_c *)(this->current_var_type_name->accept(search_base_type));

   157

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

   158

        }

   159

      }

   160

      return NULL;

   161

    }

   162

   163

    void *visit(array_specification_c* symbol) {

   164

      this->current_var_type_category = array_vtc;

   165

   166

      if (this->current_var_type_name == NULL)

   167

        this->current_var_type_name = symbol->non_generic_type_name;

   168

   169

      return NULL;

   170

    }

   171

   172

    void *visit(structure_element_declaration_list_c* symbol) {

   173

      this->current_var_type_category = structure_vtc;

   174

      return NULL;

   175

    }

   176

   177

};

   178

   179

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

   180

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

   181

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

   182

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

   183

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

   184

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

   185

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

   186

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

   187

   188

class generate_var_list_c: protected generate_c_typedecl_c {

   189

   190

  public:

   191

    typedef struct

   192

    {

   193

      symbol_c *symbol;

   194

    } SYMBOL;

   195

   196

    typedef enum {

   197

      none_dt,

   198

      programs_dt,

   199

      variables_dt

   200

    } declarationtype_t;

   201

   202

    declarationtype_t current_declarationtype;

   203

   204

    typedef enum {

   205

      none_vcc,

   206

      external_vcc,

   207

      located_input_vcc,

   208

      located_memory_vcc,

   209

      located_output_vcc,

   210

    } varclasscategory_t;

   211

   212

    varclasscategory_t current_var_class_category;

   213

   214

  private:

   215

    symbol_c *current_var_type_symbol;

   216

    symbol_c *current_var_type_name;

   217

    unsigned int current_var_number;

   218

    unsigned int step_number;

   219

    unsigned int transition_number;

   220

    unsigned int action_number;

   221

    bool configuration_defined;

   222

    std::list<SYMBOL> current_symbol_list;

   223

    search_type_symbol_c *search_type_symbol;

   224

   225

  public:

   226

    generate_var_list_c(stage4out_c *s4o_ptr, symbol_c *scope)

   227

    : generate_c_typedecl_c(s4o_ptr) {

   228

      search_type_symbol = new search_type_symbol_c(scope);

   229

      current_var_number = 0;

   230

      current_var_type_symbol = NULL;

   231

      current_var_type_name = NULL;

   232

      current_declarationtype = none_dt;

   233

      current_var_class_category = none_vcc;

   234

    }

   235

   236

    ~generate_var_list_c(void) {

   237

      delete search_type_symbol;

   238

    }

   239

   240

    void update_var_type_symbol(symbol_c *symbol) {

   241

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

   242

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

   243

    }

   244

   245

    void reset_var_type_symbol(void) {

   246

      this->current_var_type_symbol = NULL;

   247

    }

   248

   249

    void generate_programs(symbol_c *symbol) {

   250

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

   251

      current_var_number = 0;

   252

      configuration_defined = false;

   253

      current_declarationtype = programs_dt;

   254

      symbol->accept(*this);

   255

      current_declarationtype = none_dt;

   256

      s4o.print("\n");

   257

    }

   258

   259

    void generate_variables(symbol_c *symbol) {

   260

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

   261

      current_var_number = 0;

   262

      configuration_defined = false;

   263

      current_declarationtype = variables_dt;

   264

      symbol->accept(*this);

   265

      current_declarationtype = none_dt;

   266

      s4o.print("\n");

   267

    }

   268

   269

    void declare_variables(symbol_c *symbol) {

   270

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

   271

      /* should NEVER EVER occur!! */

   272

      if (list == NULL) ERROR;

   273

   274

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

   275

        declare_variable(list->elements[i]);

   276

      }

   277

    }

   278

   279

    void declare_variable(symbol_c *symbol) {

   280

      // Arrays and structures are not supported in debugging

   281

      switch (search_type_symbol->current_var_type_category) {

   282

          case search_type_symbol_c::array_vtc:

   283

          case search_type_symbol_c::structure_vtc:

   284

          return;

   285

          default:

   286

           break;

   287

      }

   288

      print_var_number();

   289

      s4o.print(";");

   290

      switch (search_type_symbol->current_var_type_category) {

   291

        case search_type_symbol_c::array_vtc:

   292

          s4o.print("ARRAY");

   293

          break;

   294

        case search_type_symbol_c::structure_vtc:

   295

          s4o.print("STRUCT");

   296

          break;

   297

        case search_type_symbol_c::function_block_vtc:

   298

          s4o.print("FB");

   299

          break;

   300

        default:

   301

          switch (this->current_var_class_category) {

   302

            case external_vcc:

   303

             s4o.print("EXT");

   304

             break;

   305

            case located_input_vcc:

   306

             s4o.print("IN");

   307

             break;

   308

            case located_memory_vcc:

   309

             s4o.print("MEM");

   310

             break;

   311

            case located_output_vcc:

   312

             s4o.print("OUT");

   313

             break;

   314

            default:

   315

             s4o.print("VAR");

   316

             break;

   317

          }

   318

          break;

   319

      }

   320

      s4o.print(";");

   321

      print_symbol_list();

   322

      symbol->accept(*this);

   323

      s4o.print(";");

   324

      print_symbol_list();

   325

      symbol->accept(*this);

   326

      s4o.print(";");

   327

      switch (search_type_symbol->current_var_type_category) {

   328

        case search_type_symbol_c::structure_vtc:

   329

        case search_type_symbol_c::function_block_vtc:

   330

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

   331

          s4o.print(";\n");

   332

          SYMBOL *current_name;

   333

          current_name = new SYMBOL;

   334

          current_name->symbol = symbol;

   335

          current_symbol_list.push_back(*current_name);

   336

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

   337

          current_symbol_list.pop_back();

   338

          break;

   339

        case search_type_symbol_c::array_vtc:

   340

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

   341

          s4o.print(";\n");

   342

          break;

   343

        default:

   344

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

   345

          s4o.print(";\n");

   346

          break;

   347

      }

   348

    }

   349

   350

    void print_var_number(void) {

   351

      char str[10];

   352

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

   353

      s4o.print(str);

   354

      current_var_number++;

   355

    }

   356

   357

    void print_step_number(void) {

   358

      char str[10];

   359

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

   360

      s4o.print(str);

   361

    }

   362

   363

    void print_transition_number(void) {

   364

      char str[10];

   365

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

   366

      s4o.print(str);

   367

    }

   368

   369

    void print_action_number(void) {

   370

      char str[10];

   371

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

   372

      s4o.print(str);

   373

    }

   374

   375

    void print_symbol_list(void) {

   376

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

   377

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

   378

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

   379

        s4o.print(".");

   380

      }

   381

    }

   382

   383

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

   384

/* B.1.4.3 - Declaration and initialization */

   385

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

   386

   387

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

   388

    /* variable_name -> may be NULL ! */

   389

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

   390

    void *visit(located_var_decl_c *symbol) {

   391

        /* Start off by setting the current_var_type_symbol and

   392

         * current_var_init_symbol private variables...

   393

         */

   394

        update_var_type_symbol(symbol->located_var_spec_init);

   395

   396

        search_location_type_c search_location_type;

   397

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

   398

          case search_location_type_c::input_lt:

   399

            this->current_var_class_category = located_input_vcc;

   400

            break;

   401

          case search_location_type_c::memory_lt:

   402

            this->current_var_class_category = located_memory_vcc;

   403

            break;

   404

          case search_location_type_c::output_lt:

   405

              this->current_var_class_category = located_output_vcc;

   406

              break;

   407

          default:

   408

            ERROR;

   409

            break;

   410

        }

   411

   412

        if (symbol->variable_name != NULL)

   413

          declare_variable(symbol->variable_name);

   414

        else

   415

          declare_variable(symbol->location);

   416

   417

        this->current_var_class_category = none_vcc;

   418

   419

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

   420

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

   421

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

   422

         */

   423

        reset_var_type_symbol();

   424

        return NULL;

   425

    }

   426

   427

    /* variable_name incompl_location ':' var_spec */

   428

    /* variable_name -> may be NULL ! */

   429

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

   430

    void *visit(incompl_located_var_decl_c *symbol) {

   431

        /* Start off by setting the current_var_type_symbol and

   432

         * current_var_init_symbol private variables...

   433

         */

   434

        update_var_type_symbol(symbol->var_spec);

   435

   436

        search_location_type_c search_location_type;

   437

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

   438

          case search_location_type_c::input_lt:

   439

            this->current_var_class_category = located_input_vcc;

   440

            break;

   441

          case search_location_type_c::memory_lt:

   442

            this->current_var_class_category = located_memory_vcc;

   443

            break;

   444

          case search_location_type_c::output_lt:

   445

            this->current_var_class_category = located_output_vcc;

   446

            break;

   447

          default:

   448

            ERROR;

   449

            break;

   450

        }

   451

   452

        if (symbol->variable_name != NULL)

   453

          declare_variable(symbol->variable_name);

   454

        else

   455

          declare_variable(symbol->incompl_location);

   456

   457

        this->current_var_class_category = none_vcc;

   458

   459

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

   460

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

   461

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

   462

        */

   463

       reset_var_type_symbol();

   464

        return NULL;

   465

    }

   466

   467

    /*  var1_list ':' array_spec_init */

   468

    // SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   469

    void *visit(array_var_init_decl_c *symbol) {

   470

      TRACE("array_var_init_decl_c");

   471

      /* Start off by setting the current_var_type_symbol and

   472

       * current_var_init_symbol private variables...

   473

       */

   474

      update_var_type_symbol(symbol->array_spec_init);

   475

   476

      declare_variables(symbol->var1_list);

   477

   478

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

   479

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

   480

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

   481

       */

   482

      reset_var_type_symbol();

   483

   484

      return NULL;

   485

    }

   486

   487

    /*  var1_list ':' array_specification */

   488

    //SYM_REF2(array_var_declaration_c, var1_list, array_specification)

   489

    void *visit(array_var_declaration_c *symbol) {

   490

       TRACE("array_var_declaration_c");

   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->array_specification);

   495

   496

       declare_variables(symbol->var1_list);

   497