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

typedef struct

    29

{

    30

  symbol_c *symbol;

    31

} SYMBOL;

    32

    33

typedef enum {

    34

  none_lt,

    35

  input_lt,

    36

  output_lt,

    37

  memory_lt

    38

} locationtype_t;

    39

    40

    41

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

    42

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

    43

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

    44

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

    45

    46

    47

class search_location_type_c: public iterator_visitor_c {

    48

    49

  public:

    50

    locationtype_t current_location_type;

    51

    52

  public:

    53

	search_location_type_c(void) {}

    54

    55

	virtual ~search_location_type_c(void) {}

    56

    57

	locationtype_t get_location_type(symbol_c *symbol) {

    58

      current_location_type = none_lt;

    59

      symbol->accept(*this);

    60

      if (current_location_type == none_lt) ERROR;

    61

      return current_location_type;

    62

	}

    63

    64

  private:

    65

    66

	void *visit(incompl_location_c* symbol) {

    67

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

    68

        current_location_type = input_lt;

    69

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

    70

        current_location_type = output_lt;

    71

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

    72

        current_location_type = memory_lt;

    73

      return NULL;

    74

	}

    75

    76

	void *visit(direct_variable_c *symbol) {

    77

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

    78

        current_location_type = input_lt;

    79

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

    80

        current_location_type = output_lt;

    81

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

    82

        current_location_type = memory_lt;

    83

      return NULL;

    84

	}

    85

};

    86

    87

    88

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

    89

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

    90

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

    91

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

    92

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

    93

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

    94

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

    95

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

    96

    97

class generate_var_list_c: protected generate_c_typedecl_c {

    98

    99

  public:

   100

    typedef enum {

   101

      none_dt,

   102

      programs_dt,

   103

      variables_dt

   104

    } declarationtype_t;

   105

   106

    declarationtype_t current_declarationtype;

   107

   108

    typedef enum {

   109

      none_vtc,

   110

      variable_vtc,

   111

      external_vtc,

   112

      located_input_vtc,

   113

      located_memory_vtc,

   114

      located_output_vtc,

   115

      array_vtc,

   116

      structure_vtc,

   117

      function_block_vtc

   118

    } vartypecategory_t;

   119

   120

    vartypecategory_t current_var_type_category;

   121

   122

  private:

   123

    symbol_c *current_var_type_symbol;

   124

    symbol_c *current_var_type_name;

   125

    unsigned int current_var_number;

   126

    unsigned int step_number;

   127

    unsigned int transition_number;

   128

    unsigned int action_number;

   129

    bool configuration_defined;

   130

    std::list<SYMBOL> current_symbol_list;

   131

    search_base_type_c search_base_type;

   132

    search_fb_typedecl_c *search_fb_typedecl;

   133

   134

  public:

   135

    generate_var_list_c(stage4out_c *s4o_ptr, symbol_c *scope)

   136

    : generate_c_typedecl_c(s4o_ptr) {

   137

      search_fb_typedecl = new search_fb_typedecl_c(scope);

   138

      current_var_number = 0;

   139

      current_var_type_symbol = current_var_type_name = NULL;

   140

      current_declarationtype = none_dt;

   141

      current_var_type_category = none_vtc;

   142

    }

   143

   144

    ~generate_var_list_c(void) {

   145

      delete search_fb_typedecl;

   146

    }

   147

   148

    void update_var_type_symbol(symbol_c *symbol) {

   149

   150

      this->current_var_type_name = spec_init_sperator_c::get_spec(symbol);

   151

      if (this->current_var_type_name == NULL) {

   152

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

   153

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

   154

          fprintf(stderr, "%s.", ((identifier_c*)(pt->symbol))->value);

   155

        }

   156

        ERROR;

   157

      }

   158

   159

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

   160

      if (this->current_var_type_symbol != NULL)

   161

        this->current_var_type_category = function_block_vtc;

   162

      else {

   163

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

   164

   165

        structure_element_declaration_list_c *structure_symbol = dynamic_cast<structure_element_declaration_list_c *>(this->current_var_type_symbol);

   166

        if (structure_symbol != NULL)

   167

          this->current_var_type_category = structure_vtc;

   168

        else

   169

          this->current_var_type_category = variable_vtc;

   170

      }

   171

   172

      if (this->current_var_type_symbol == NULL)

   173

        ERROR;

   174

    }

   175

   176

    void reset_var_type_symbol(void) {

   177

      this->current_var_type_symbol = NULL;

   178

    }

   179

   180

    void generate_programs(symbol_c *symbol) {

   181

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

   182

      current_var_number = 0;

   183

      configuration_defined = false;

   184

      current_declarationtype = programs_dt;

   185

      symbol->accept(*this);

   186

      current_declarationtype = none_dt;

   187

      s4o.print("\n");

   188

    }

   189

   190

    void generate_variables(symbol_c *symbol) {

   191

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

   192

      current_var_number = 0;

   193

      configuration_defined = false;

   194

      current_declarationtype = variables_dt;

   195

      symbol->accept(*this);

   196

      current_declarationtype = none_dt;

   197

      s4o.print("\n");

   198

    }

   199

   200

    void declare_variables(symbol_c *symbol) {

   201

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

   202

      /* should NEVER EVER occur!! */

   203

      if (list == NULL) ERROR;

   204

   205

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

   206

        declare_variable(list->elements[i]);

   207

      }

   208

    }

   209

   210

    void declare_variable(symbol_c *symbol) {

   211

      // Arrays and structures are not supported in debugging

   212

      switch (this->current_var_type_category) {

   213

      	case array_vtc:

   214

      	case structure_vtc:

   215

          return;

   216

      	default:

   217

      	  break;

   218

      }

   219

      print_var_number();

   220

      s4o.print(";");

   221

      switch (this->current_var_type_category) {

   222

        case external_vtc:

   223

          s4o.print("EXT");

   224

          break;

   225

        case located_input_vtc:

   226

          s4o.print("IN");

   227

          break;

   228

        case located_memory_vtc:

   229

          s4o.print("MEM");

   230

          break;

   231

        case located_output_vtc:

   232

          s4o.print("OUT");

   233

          break;

   234

        case array_vtc:

   235

          s4o.print("ARRAY");

   236

          break;

   237

        case structure_vtc:

   238

          s4o.print("STRUCT");

   239

          break;

   240

        case function_block_vtc:

   241

          s4o.print("FB");

   242

          break;

   243

        default:

   244

          s4o.print("VAR");

   245

          break;

   246

      }

   247

      s4o.print(";");

   248

      print_symbol_list();

   249

      symbol->accept(*this);

   250

      s4o.print(";");

   251

      print_symbol_list();

   252

      symbol->accept(*this);

   253

      s4o.print(";");

   254

      switch (this->current_var_type_category) {

   255

        case structure_vtc:

   256

        case function_block_vtc:

   257

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

   258

          s4o.print(";\n");

   259

          SYMBOL *current_name;

   260

          current_name = new SYMBOL;

   261

          current_name->symbol = symbol;

   262

          current_symbol_list.push_back(*current_name);

   263

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

   264

          current_symbol_list.pop_back();

   265

          break;

   266

        case array_vtc:

   267

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

   268

          s4o.print(";\n");

   269

          break;

   270

        default:

   271

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

   272

          s4o.print(";\n");

   273

          break;

   274

      }

   275

    }

   276

   277

    void print_var_number(void) {

   278

      char str[10];

   279

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

   280

      s4o.print(str);

   281

      current_var_number++;

   282

    }

   283

   284

    void print_step_number(void) {

   285

      char str[10];

   286

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

   287

      s4o.print(str);

   288

    }

   289

   290

    void print_transition_number(void) {

   291

      char str[10];

   292

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

   293

      s4o.print(str);

   294

    }

   295

   296

    void print_action_number(void) {

   297

      char str[10];

   298

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

   299

      s4o.print(str);

   300

    }

   301

   302

    void print_symbol_list(void) {

   303

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

   304

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

   305

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

   306

        s4o.print(".");

   307

      }

   308

    }

   309

   310

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

   311

/* B.1.4.3 - Declaration and initialization */

   312

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

   313

   314

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

   315

    /* variable_name -> may be NULL ! */

   316

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

   317

    void *visit(located_var_decl_c *symbol) {

   318

        /* Start off by setting the current_var_type_symbol and

   319

         * current_var_init_symbol private variables...

   320

         */

   321

        update_var_type_symbol(symbol->located_var_spec_init);

   322

   323

        search_location_type_c search_location_type;

   324

        locationtype_t location_type = search_location_type.get_location_type(symbol->location);

   325

        if (location_type == input_lt)

   326

          this->current_var_type_category = located_input_vtc;

   327

        else if (location_type == memory_lt)

   328

          this->current_var_type_category = located_memory_vtc;

   329

        else if (location_type == output_lt)

   330

          this->current_var_type_category = located_output_vtc;

   331

   332

        if (symbol->variable_name != NULL)

   333

          declare_variable(symbol->variable_name);

   334

        else

   335

          declare_variable(symbol->location);

   336

   337

        current_var_type_symbol = NULL;

   338

        return NULL;

   339

    }

   340

   341

    /* variable_name incompl_location ':' var_spec */

   342

    /* variable_name -> may be NULL ! */

   343

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

   344

    void *visit(incompl_located_var_decl_c *symbol) {

   345

        /* Start off by setting the current_var_type_symbol and

   346

         * current_var_init_symbol private variables...

   347

         */

   348

        update_var_type_symbol(symbol->var_spec);

   349

   350

        search_location_type_c search_location_type;

   351

        locationtype_t location_type = search_location_type.get_location_type(symbol->incompl_location);

   352

        if (location_type == input_lt)

   353

          this->current_var_type_category = located_input_vtc;

   354

        else if (location_type == memory_lt)

   355

          this->current_var_type_category = located_memory_vtc;

   356

        else if (location_type == output_lt)

   357

          this->current_var_type_category = located_output_vtc;

   358

   359

        if (symbol->variable_name != NULL)

   360

          declare_variable(symbol->variable_name);

   361

        else

   362

          declare_variable(symbol->incompl_location);

   363

   364

        current_var_type_symbol = NULL;

   365

        return NULL;

   366

    }

   367

   368

    /*  var1_list ':' array_spec_init */

   369

    // SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   370

    void *visit(array_var_init_decl_c *symbol) {

   371

      TRACE("array_var_init_decl_c");

   372

      /* Start off by setting the current_var_type_symbol and

   373

       * current_var_init_symbol private variables...

   374

       */

   375

      update_var_type_symbol(symbol->array_spec_init);

   376

   377

      this->current_var_type_category = array_vtc;

   378

      declare_variables(symbol->var1_list);

   379

   380

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

   381

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

   382

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

   383

       */

   384

      reset_var_type_symbol();

   385

   386

      return NULL;

   387

    }

   388

   389

    /*  var1_list ':' initialized_structure */

   390

    // SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure)

   391

    void *visit(structured_var_init_decl_c *symbol) {

   392

      TRACE("structured_var_init_decl_c");

   393

      /* Please read the comments inside the var1_init_decl_c

   394

       * visitor, as they apply here too.

   395

       */

   396

   397

      /* Start off by setting the current_var_type_symbol and

   398

       * current_var_init_symbol private variables...

   399

       */

   400

      update_var_type_symbol(symbol->initialized_structure);

   401

   402

      /* now to produce the c equivalent... */

   403

      this->current_var_type_category = structure_vtc;

   404

      declare_variables(symbol->var1_list);

   405

   406

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

   407

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

   408

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

   409

       */

   410

      reset_var_type_symbol();

   411

   412

      return NULL;

   413

    }

   414

   415

    /* fb_name_list ':' function_block_type_name ASSIGN structure_initialization */

   416

    /* structure_initialization -> may be NULL ! */

   417

    void *visit(fb_name_decl_c *symbol) {

   418

      TRACE("fb_name_decl_c");

   419

      /* Please read the comments inside the var1_init_decl_c

   420

       * visitor, as they apply here too.

   421

       */

   422

   423

      /* Start off by setting the current_var_type_symbol and

   424

       * current_var_init_symbol private variables...

   425

       */

   426

      update_var_type_symbol(symbol);

   427

   428

      /* now to produce the c equivalent... */

   429

      declare_variables(symbol->fb_name_list);

   430

   431

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

   432

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

   433

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

   434

       */

   435

      reset_var_type_symbol();

   436

   437

      return NULL;

   438

    }

   439

   440

    /*  global_var_name ':' (simple_specification|subrange_specification|enumerated_specification|array_specification|prev_declared_structure_type_name|function_block_type_name */

   441

    //SYM_REF2(external_declaration_c, global_var_name, specification)

   442

    void *visit(external_declaration_c *symbol) {

   443

      TRACE("external_declaration_c");

   444

      /* Please read the comments inside the var1_init_decl_c

   445

       * visitor, as they apply here too.

   446

       */

   447

   448

      /* Start off by setting the current_var_type_symbol and

   449

       * current_var_init_symbol private variables...

   450

       */

   451

      update_var_type_symbol(symbol->specification);

   452

   453

      /* now to produce the c equivalent... */

   454

      this->current_var_type_category = external_vtc;

   455

      declare_variable(symbol->global_var_name);

   456

   457

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

   458

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

   459

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

   460

       */

   461

      reset_var_type_symbol();

   462

   463

      return NULL;

   464

    }

   465

   466

    /*| global_var_spec ':' [located_var_spec_init|function_block_type_name] */

   467

    /* type_specification ->may be NULL ! */

   468

    // SYM_REF2(global_var_decl_c, global_var_spec, type_specification)

   469

    void *visit(global_var_decl_c *symbol) {

   470

      TRACE("global_var_decl_c");

   471

      /* Please read the comments inside the var1_init_decl_c

   472

       * visitor, as they apply here too.

   473

       */

   474

   475

      /* Start off by setting the current_var_type_symbol and

   476

       * current_var_init_symbol private variables...

   477

       */

   478

      update_var_type_symbol(symbol->type_specification);

   479

   480

      /* now to produce the c equivalent... */

   481

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

   482

   483

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

   484

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

   485

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

   486

       */

   487

      reset_var_type_symbol();

   488

   489

      return NULL;

   490

    }

   491

   492

    void *visit(global_var_list_c *symbol) {

   493

      declare_variables(symbol);

   494

      return NULL;

   495

    }

   496

   497

    /*| global_var_name location */

   498

    // SYM_REF2(global_var_spec_c, global_var_name, location)

   499

    void *visit(global_var_spec_c *symbol) {

   500

      search_location_type_c search_location_type;

   501

	  locationtype_t location_type = search_location_type.get_location_type(symbol->location);

   502

	  if (location_type == input_lt)

   503

        this->current_var_type_category = located_input_vtc;

   504

      else if (location_type == memory_lt)

   505

        this->current_var_type_category = located_memory_vtc;

   506

      else if (location_type == output_lt)