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

      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;

   220

        case located_memory_vtc:

   221

          s4o.print("MEM");

   222

          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 == memory_lt)

   320

          this->current_var_type_category = located_memory_vtc;

   321

        else if (location_type == output_lt)

   322

          this->current_var_type_category = located_output_vtc;

   323

   324

        if (symbol->variable_name != NULL)

   325

          declare_variable(symbol->variable_name);

   326

        else

   327

          declare_variable(symbol->location);

   328

   329

        current_var_type_symbol = NULL;

   330

        return NULL;

   331

    }

   332

   333

    /* variable_name incompl_location ':' var_spec */

   334

    /* variable_name -> may be NULL ! */

   335

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

   336

    void *visit(incompl_located_var_decl_c *symbol) {

   337

        /* Start off by setting the current_var_type_symbol and

   338

         * current_var_init_symbol private variables...

   339

         */

   340

        update_var_type_symbol(symbol->var_spec);

   341

   342

        search_location_type_c search_location_type;

   343

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

   344

        if (location_type == input_lt)

   345

          this->current_var_type_category = located_input_vtc;

   346

        else if (location_type == memory_lt)

   347

          this->current_var_type_category = located_memory_vtc;

   348

        else if (location_type == output_lt)

   349

          this->current_var_type_category = located_output_vtc;

   350

   351

        if (symbol->variable_name != NULL)

   352

          declare_variable(symbol->variable_name);

   353

        else

   354

          declare_variable(symbol->incompl_location);

   355

   356

        current_var_type_symbol = NULL;

   357

        return NULL;

   358

    }

   359

   360

    /*  var1_list ':' array_spec_init */

   361

    // SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   362

    void *visit(array_var_init_decl_c *symbol) {

   363

      TRACE("array_var_init_decl_c");

   364

      /* Start off by setting the current_var_type_symbol and

   365

       * current_var_init_symbol private variables...

   366

       */

   367

      update_var_type_symbol(symbol->array_spec_init);

   368

   369

      this->current_var_type_category = array_vtc;

   370

      //declare_variables(symbol->var1_list);

   371

   372

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

   373

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

   374

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

   375

       */

   376

      reset_var_type_symbol();

   377

   378

      return NULL;

   379

    }

   380

   381

    /*  var1_list ':' initialized_structure */

   382

    // SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure)

   383

    void *visit(structured_var_init_decl_c *symbol) {

   384

      TRACE("structured_var_init_decl_c");

   385

      /* Please read the comments inside the var1_init_decl_c

   386

       * visitor, as they apply here too.

   387

       */

   388

   389

      /* Start off by setting the current_var_type_symbol and

   390

       * current_var_init_symbol private variables...

   391

       */

   392

      update_var_type_symbol(symbol->initialized_structure);

   393

   394

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

   395

      //declare_variables(symbol->var1_list);

   396

   397

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

   398

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

   399

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

   400

       */

   401

      reset_var_type_symbol();

   402

   403

      return NULL;

   404

    }

   405

   406

    /* fb_name_list ':' function_block_type_name ASSIGN structure_initialization */

   407

    /* structure_initialization -> may be NULL ! */

   408

    void *visit(fb_name_decl_c *symbol) {

   409

      TRACE("fb_name_decl_c");

   410

      /* Please read the comments inside the var1_init_decl_c

   411

       * visitor, as they apply here too.

   412

       */

   413

   414

      /* Start off by setting the current_var_type_symbol and

   415

       * current_var_init_symbol private variables...

   416

       */

   417

      update_var_type_symbol(symbol);

   418

   419

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

   420

      declare_variables(symbol->fb_name_list);

   421

   422

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

   423

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

   424

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

   425

       */

   426

      reset_var_type_symbol();

   427

   428

      return NULL;

   429

    }

   430

   431

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

   432

    //SYM_REF2(external_declaration_c, global_var_name, specification)

   433

    void *visit(external_declaration_c *symbol) {

   434

      TRACE("external_declaration_c");

   435

      /* Please read the comments inside the var1_init_decl_c

   436

       * visitor, as they apply here too.

   437

       */

   438

   439

      /* Start off by setting the current_var_type_symbol and

   440

       * current_var_init_symbol private variables...

   441

       */

   442

      update_var_type_symbol(symbol->specification);

   443

   444

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

   445

      this->current_var_type_category = external_vtc;

   446

      declare_variable(symbol->global_var_name);

   447

   448

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

   449

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

   450

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

   451

       */

   452

      reset_var_type_symbol();

   453

   454

      return NULL;

   455

    }

   456

   457

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

   458

    /* type_specification ->may be NULL ! */

   459

    // SYM_REF2(global_var_decl_c, global_var_spec, type_specification)

   460

    void *visit(global_var_decl_c *symbol) {

   461

      TRACE("global_var_decl_c");

   462

      /* Please read the comments inside the var1_init_decl_c

   463

       * visitor, as they apply here too.

   464

       */

   465

   466

      /* Start off by setting the current_var_type_symbol and

   467

       * current_var_init_symbol private variables...

   468

       */

   469

      update_var_type_symbol(symbol->type_specification);

   470

   471

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

   472

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

   473

   474

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

   475

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

   476

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

   477

       */

   478

      reset_var_type_symbol();

   479

   480

      return NULL;

   481

    }

   482

   483

    void *visit(global_var_list_c *symbol) {

   484

      declare_variables(symbol);

   485

      return NULL;

   486

    }

   487

   488

    /*| global_var_name location */

   489

    // SYM_REF2(global_var_spec_c, global_var_name, location)

   490

    void *visit(global_var_spec_c *symbol) {

   491

      search_location_type_c search_location_type;

   492

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

   493

	  if (location_type == input_lt)

   494

        this->current_var_type_category = located_input_vtc;

   495

      else if (location_type == memory_lt)

   496

        this->current_var_type_category = located_memory_vtc;

   497

      else if (location_type == output_lt)

   498

        this->current_var_type_category = located_output_vtc;

   499

   500

      if (symbol->global_var_name != NULL)

   501

        declare_variable(symbol->global_var_name);

   502

      else

   503

        declare_variable(symbol->location);

   504

      return NULL;

   505

    }

   506

   507