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,

   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

      print_var_number();

   212

      s4o.print(";");

   213

      switch (this->current_var_type_category) {

   214

        case external_vtc:

   215

          s4o.print("EXT");

   216

          break;

   217

        case located_input_vtc:

   218

          s4o.print("IN");

   219

          break;

   223

        case located_output_vtc:

   224

          s4o.print("OUT");

   225

          break;

   226

        case array_vtc:

   227

          s4o.print("ARRAY");

   228

          break;

   229

        case structure_vtc:

   230

          s4o.print("STRUCT");

   231

          break;

   232

        case function_block_vtc:

   233

          s4o.print("FB");

   234

          break;

   235

        default:

   236

          s4o.print("VAR");

   237

          break;

   238

      }

   239

      s4o.print(";");

   240

      print_symbol_list();

   241

      symbol->accept(*this);

   242

      s4o.print(";");

   243

      print_symbol_list();

   244

      symbol->accept(*this);

   245

      s4o.print(";");

   246

      switch (this->current_var_type_category) {

   247

        case structure_vtc:

   248

        case function_block_vtc:

   249

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

   250

          s4o.print(";\n");

   251

          SYMBOL *current_name;

   252

          current_name = new SYMBOL;

   253

          current_name->symbol = symbol;

   254

          current_symbol_list.push_back(*current_name);

   255

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

   256

          current_symbol_list.pop_back();

   257

          break;

   258

        case array_vtc:

   259

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

   260

          s4o.print(";\n");

   261

          break;

   262

        default:

   263

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

   264

          s4o.print(";\n");

   265

          break;

   266

      }

   267

    }

   268

   269

    void print_var_number(void) {

   270

      char str[10];

   271

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

   272

      s4o.print(str);

   273

      current_var_number++;

   274

    }

   275

   276

    void print_step_number(void) {

   277

      char str[10];

   278

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

   279

      s4o.print(str);

   280

    }

   281

   282

    void print_transition_number(void) {

   283

      char str[10];

   284

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

   285

      s4o.print(str);

   286

    }

   287

   288

    void print_action_number(void) {

   289

      char str[10];

   290

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

   291

      s4o.print(str);

   292

    }

   293

   294

    void print_symbol_list(void) {

   295

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

   296

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

   297

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

   298

        s4o.print(".");

   299

      }

   300

    }

   301

   302

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

   303

/* B.1.4.3 - Declaration and initialization */

   304

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

   305

   306

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

   307

    /* variable_name -> may be NULL ! */

   308

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

   309

    void *visit(located_var_decl_c *symbol) {

   310

        /* Start off by setting the current_var_type_symbol and

   311

         * current_var_init_symbol private variables...

   312

         */

   313

        update_var_type_symbol(symbol->located_var_spec_init);

   314

   315

        search_location_type_c search_location_type;

   316

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

   317

        if (location_type == input_lt)

   318

          this->current_var_type_category = located_input_vtc;

   319

        else if (location_type == output_lt)

   320

          this->current_var_type_category = located_output_vtc;

   321

   322

        if (symbol->variable_name != NULL)

   323

          declare_variable(symbol->variable_name);

   324

        else

   325

          declare_variable(symbol->location);

   326

   327

        current_var_type_symbol = NULL;

   328

        return NULL;

   329

    }

   330

   331

    /* variable_name incompl_location ':' var_spec */

   332

    /* variable_name -> may be NULL ! */

   333

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

   334

    void *visit(incompl_located_var_decl_c *symbol) {

   335

        /* Start off by setting the current_var_type_symbol and

   336

         * current_var_init_symbol private variables...

   337

         */

   338

        update_var_type_symbol(symbol->var_spec);

   339

   340

        search_location_type_c search_location_type;

   341

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

   342

        if (location_type == input_lt)

   343

          this->current_var_type_category = located_input_vtc;

   344

        else if (location_type == output_lt)

   345

          this->current_var_type_category = located_output_vtc;

   346

   347

        if (symbol->variable_name != NULL)

   348

          declare_variable(symbol->variable_name);

   349

        else

   350

          declare_variable(symbol->incompl_location);

   351

   352

        current_var_type_symbol = NULL;

   353

        return NULL;

   354

    }

   355

   356

    /*  var1_list ':' array_spec_init */

   357

    // SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   358

    void *visit(array_var_init_decl_c *symbol) {

   359

      TRACE("array_var_init_decl_c");

   360

      /* Start off by setting the current_var_type_symbol and

   361

       * current_var_init_symbol private variables...

   362

       */

   363

      update_var_type_symbol(symbol->array_spec_init);

   364

   365

      this->current_var_type_category = array_vtc;

   366

      //declare_variables(symbol->var1_list);

   367

   368

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

   369

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

   370

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

   371

       */

   372

      reset_var_type_symbol();

   373

   374

      return NULL;

   375

    }

   376

   377

    /*  var1_list ':' initialized_structure */

   378

    // SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure)

   379

    void *visit(structured_var_init_decl_c *symbol) {

   380

      TRACE("structured_var_init_decl_c");

   381

      /* Please read the comments inside the var1_init_decl_c

   382

       * visitor, as they apply here too.

   383

       */

   384

   385

      /* Start off by setting the current_var_type_symbol and

   386

       * current_var_init_symbol private variables...

   387

       */

   388

      update_var_type_symbol(symbol->initialized_structure);

   389

   390

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

   391

      //declare_variables(symbol->var1_list);

   392

   393

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

   394

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

   395

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

   396

       */

   397

      reset_var_type_symbol();

   398

   399

      return NULL;

   400

    }

   401

   402

    /* fb_name_list ':' function_block_type_name ASSIGN structure_initialization */

   403

    /* structure_initialization -> may be NULL ! */

   404

    void *visit(fb_name_decl_c *symbol) {

   405

      TRACE("fb_name_decl_c");

   406

      /* Please read the comments inside the var1_init_decl_c

   407

       * visitor, as they apply here too.

   408

       */

   409

   410

      /* Start off by setting the current_var_type_symbol and

   411

       * current_var_init_symbol private variables...

   412

       */

   413

      update_var_type_symbol(symbol);

   414

   415

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

   416

      declare_variables(symbol->fb_name_list);

   417

   418

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

   419

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

   420

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

   421

       */

   422

      reset_var_type_symbol();

   423

   424

      return NULL;

   425

    }

   426

   427

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

   428

    //SYM_REF2(external_declaration_c, global_var_name, specification)

   429

    void *visit(external_declaration_c *symbol) {

   430

      TRACE("external_declaration_c");

   431

      /* Please read the comments inside the var1_init_decl_c

   432

       * visitor, as they apply here too.

   433

       */

   434

   435

      /* Start off by setting the current_var_type_symbol and

   436

       * current_var_init_symbol private variables...

   437

       */

   438

      update_var_type_symbol(symbol->specification);

   439

   440

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

   441

      this->current_var_type_category = external_vtc;

   442

      declare_variable(symbol->global_var_name);

   443

   444

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

   445

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

   446

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

   447

       */

   448

      reset_var_type_symbol();

   449

   450

      return NULL;

   451

    }

   452

   453

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

   454

    /* type_specification ->may be NULL ! */

   455

    // SYM_REF2(global_var_decl_c, global_var_spec, type_specification)

   456

    void *visit(global_var_decl_c *symbol) {

   457

      TRACE("global_var_decl_c");

   458

      /* Please read the comments inside the var1_init_decl_c

   459

       * visitor, as they apply here too.

   460

       */

   461

   462

      /* Start off by setting the current_var_type_symbol and

   463

       * current_var_init_symbol private variables...

   464

       */

   465

      update_var_type_symbol(symbol->type_specification);

   466

   467

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

   468

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

   469

   470

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

   471

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

   472

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

   473

       */

   474

      reset_var_type_symbol();

   475

   476

      return NULL;

   477

    }

   478

   479

    void *visit(global_var_list_c *symbol) {

   480

      declare_variables(symbol);

   481

      return NULL;

   482

    }

   483

   484

    /*| global_var_name location */

   485

    // SYM_REF2(global_var_spec_c, global_var_name, location)

   486

    void *visit(global_var_spec_c *symbol) {

   487

      search_location_type_c search_location_type;

   488

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

   489

	  if (location_type == input_lt)

   490

        this->current_var_type_category = located_input_vtc;

   493

      else if (location_type == output_lt)

   494

        this->current_var_type_category = located_output_vtc;

   495

   496

      if (symbol->global_var_name != NULL)

   497

        declare_variable(symbol->global_var_name);

   498

      else

   499

        declare_variable(symbol->location);

   500

      return NULL;

   501

    }

   502

   503

    void *visit(var1_init_decl_c *symbol) {

   504

      TRACE("var1_init_decl_c");

   505

   506

      /* Start off by setting the current_var_type_symbol and

   507

       * current_var_init_symbol private variables...