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

 *

    21

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

    22

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

    23

 */

    24

    25

class initialization_analyzer_c: public null_visitor_c {

    26

  public:

    27

	typedef enum {

    28

	  simple_it,

    29

	  array_it,

    30

	  struct_it

    31

	} initialization_type_t;

    32

    33

  private:

    34

    35

	initialization_type_t current_type;

    36

    37

  public:

    38

	initialization_analyzer_c(symbol_c* symbol) {

    39

	  current_type = simple_it;

    40

      symbol->accept(*this);

    41

	}

    42

	~initialization_analyzer_c(void) {}

    43

    44

	initialization_type_t get_initialization_type(void) {

    45

	  return current_type;

    46

	}

    47

    48

	void *visit(array_initial_elements_list_c *symbol) {

    49

      current_type = array_it;

    50

      return NULL;

    51

	}

    52

    53

    void *visit(structure_element_initialization_list_c *symbol) {

    54

      current_type = struct_it;

    55

      return NULL;

    56

    }

    57

};

    58

    59

class generate_c_array_initialization_c: public generate_c_typedecl_c {

    60

    61

  public:

    62

    typedef enum {

    63

      none_am,

    64

      arraysize_am,

    65

      typedecl_am,

    66

      initializationvalue_am

    67

    } arrayinitialization_mode_t;

    68

    69

    arrayinitialization_mode_t current_mode;

    70

    71

    symbol_c* array_base_type;

    72

    symbol_c* array_default_value;

    73

    symbol_c* array_default_initialization;

    74

    75

  private:

    76

    int current_dimension;

    77

    int array_size;

    78

    int defined_values_count;

    79

    int current_initialization_count;

    80

    81

  public:

    82

    generate_c_array_initialization_c(stage4out_c *s4o_ptr): generate_c_typedecl_c(s4o_ptr) {}

    83

    ~generate_c_array_initialization_c(void) {}

    84

    85

    void init_array_size(symbol_c *array_specification) {

    86

      array_size = 1;

    87

      defined_values_count = 0;

    88

      current_initialization_count = 0;

    89

      array_base_type = array_default_value = array_default_initialization = NULL;

    90

    91

      current_mode = arraysize_am;

    92

      array_specification->accept(*this);

    93

    }

    94

    95

    void init_array(symbol_c *var1_list, symbol_c *array_specification, symbol_c *array_initialization) {

    96

      int i;

    97

    98

      init_array_size(array_specification);

    99

   100

      s4o.print("\n");

   101

      s4o.print(s4o.indent_spaces + "{\n");

   102

      s4o.indent_right();

   103

      s4o.print(s4o.indent_spaces);

   104

      s4o.print("static const ");

   105

   106

      current_mode = typedecl_am;

   107

      array_specification->accept(*this);

   108

      s4o.print(" temp = ");

   109

   110

      init_array_values(array_initialization);

   111

   112

      s4o.print(";\n");

   113

      var1_list->accept(*this);

   114

      s4o.indent_left();

   115

      s4o.print(s4o.indent_spaces + "}");

   116

    }

   117

   118

    void init_array_values(symbol_c *array_initialization) {

   119

      s4o.print("{{");

   120

   121

      current_mode = initializationvalue_am;

   122

      array_initialization->accept(*this);

   123

   124

      if (array_default_initialization != NULL && defined_values_count < array_size)

   125

        array_default_initialization->accept(*this);

   126

      if (defined_values_count < array_size) {

   127

        for (int i = defined_values_count; i < array_size; i++) {

   128

          if (defined_values_count > 0)

   129

            s4o.print(",");

   130

          array_default_value->accept(*this);

   131

          defined_values_count++;

   132

        }

   133

      }

   134

   135

      s4o.print("}}");

   136

    }

   137

   138

    void *visit(identifier_c *type_name) {

   139

      symbol_c *type_decl;

   140

      switch (current_mode) {

   141

        case arraysize_am:

   142

          /* look up the type declaration... */

   143

          type_decl = type_symtable.find_value(type_name);

   144

          if (type_decl == type_symtable.end_value())

   145

            /* Type declaration not found!! */

   146

            ERROR;

   147

          type_decl->accept(*this);

   148

          break;

   149

        default:

   150

          print_token(type_name);

   151

          break;

   152

      }

   153

      return NULL;

   154

    }

   155

   156

    void *visit(var1_list_c *symbol) {

   157

      int i, j;

   158

   159

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

   160

        s4o.print(s4o.indent_spaces);

   161

        s4o.print(SET_VAR);

   162

        s4o.print("(");

   163

        print_variable_prefix();

   164

        s4o.print(",");

   165

        symbol->elements[i]->accept(*this);

   166

        s4o.print(",temp);\n");

   167

      }

   168

      return NULL;

   169

    }

   170

   171

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

   172

/* B 1.3.3 - Derived data types */

   173

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

   174

   175

    /* array_specification [ASSIGN array_initialization] */

   176

    /* array_initialization may be NULL ! */

   177

    void *visit(array_spec_init_c *symbol) {

   178

      switch (current_mode) {

   179

        case arraysize_am:

   180

          array_default_initialization = symbol->array_initialization;

   181

          break;

   182

        default:

   183

          break;

   184

      }

   185

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

   186

      return NULL;

   187

    }

   188

   189

    /* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */

   190

    void *visit(array_specification_c *symbol) {

   191

      identifier_c* type_name;

   192

      switch (current_mode) {

   193

        case arraysize_am:

   194

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

   195

          array_base_type = symbol->non_generic_type_name;

   196

          array_default_value = (symbol_c *)symbol->non_generic_type_name->accept(*type_initial_value_c::instance());;

   197

          if (array_default_value == NULL) ERROR;

   198

          break;

   199

        case typedecl_am:

   200

          s4o.print("__");

   201

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

   202

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

   203

          break;

   204

        default:

   205

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

   206

          break;

   207

      } 

   208

      return NULL;

   209

    }

   210

   211

    /*  signed_integer DOTDOT signed_integer */

   212

    //SYM_REF2(subrange_c, lower_limit, upper_limit)

   213

    void *visit(subrange_c *symbol) {

   215

      switch (current_mode) {

   216

        case arraysize_am:

   217

          array_size *= dimension;

   218

          break;

   219

        case typedecl_am:

   220

          s4o.print("_");

   221

          s4o.print_integer(dimension);

   222

          break;

   223

        default:

   224

          break;

   225

      }

   226

      return NULL;

   227

    }

   228

   229

    /* helper symbol for array_initialization */

   230

    /* array_initial_elements_list ',' array_initial_elements */

   231

    void *visit(array_initial_elements_list_c *symbol) {

   232

      switch (current_mode) {

   233

        case initializationvalue_am:

   234

          current_initialization_count = 0;

   235

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

   236

            if (current_initialization_count >= defined_values_count) {

   237

              if (defined_values_count >= array_size)

   238

                ERROR;

   239

              if (defined_values_count > 0)

   240

                s4o.print(",");

   241

              symbol->elements[i]->accept(*this);

   242

              defined_values_count++;

   243

            }

   244

            else {

   245

              array_initial_elements_c *array_initial_element = dynamic_cast<array_initial_elements_c *>(symbol->elements[i]);

   246

   247

              if (array_initial_element != NULL) {

   248

            	  symbol->elements[i]->accept(*this);

   249

              }

   250

            }

   251

            current_initialization_count++;

   252

          }

   253

          break;

   254

        default:

   255

          break;

   256

      }

   257

      return NULL;

   258

    }

   259

   260

    /* integer '(' [array_initial_element] ')' */

   261

    /* array_initial_element may be NULL ! */

   262

    void *visit(array_initial_elements_c *symbol) {

   263

      int initial_element_number;

   264

   265

      switch (current_mode) {

   266

        case initializationvalue_am:

   268

          if (current_initialization_count < defined_values_count) {

   269

            int temp_element_number = 0;

   270

            int diff = defined_values_count - current_initialization_count;

   271

            if (diff <= initial_element_number)

   272

              temp_element_number = initial_element_number - diff;

   273

            current_initialization_count += initial_element_number - 1;

   274

            initial_element_number = temp_element_number;

   275

            if (initial_element_number > 0) {

   276

              defined_values_count++;

   277

              s4o.print(",");

   278

            }

   279

          }

   280

          else

   281

            current_initialization_count += initial_element_number - 1;

   282

          if (defined_values_count + initial_element_number > array_size)

   283

            ERROR;

   284

          for (int i = 0; i < initial_element_number; i++) {

   285

            if (i > 0)

   286

              s4o.print(",");

   287

            if (symbol->array_initial_element != NULL) {

   288

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

   289

            }

   290

            else {

   291

              array_default_value->accept(*this);

   292

            }

   293

          }

   294

          if (initial_element_number > 1)

   295

            defined_values_count += initial_element_number - 1;

   296

          break;

   297

        default:

   298

          break;

   299

      }

   300

      return NULL;

   301

    }

   302

   303

    void *visit(structure_element_initialization_list_c *symbol);

   304

};

   305

   306

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

   307

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

   308

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

   309

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

   310

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

   311

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

   312

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

   313

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

   314

   315

/* given a structure_element_declaration_list_c, iterate 

   316

 * through each element, returning the name

   317

 * of each element...structure_element_iterator_c

   318

 */

   319

class structure_element_iterator_c : public null_visitor_c {

   320

   321

  private:

   322

    /* a pointer to the structure_element_declaration_list_c

   323

     * currently being analysed.

   324

     */

   325

    symbol_c *type_decl;

   326

    int next_element, element_count;

   327

    identifier_c *current_element_name;

   328

    symbol_c *current_element_type;

   329

    symbol_c *current_element_default_value;

   330

   331

   332

  public:

   333

    /* start off at the first parameter once again... */

   334

    void reset(void) {

   335

      next_element = element_count = 0;

   336

      current_element_name = NULL;

   337

      current_element_type = current_element_default_value = NULL;

   338

    }

   339

   340

    /* initialise the iterator object.

   341

     * We must be given a reference to the function declaration

   342

     * that will be analysed...

   343

     */

   344

    structure_element_iterator_c(symbol_c *type_decl) {

   345

      this->type_decl = type_decl;

   346

      reset();

   347

    }

   348

   349

    /* Skip to the next element. After object creation,

   350

     * the object references on 

   351

     * element _before_ the first, so

   352

     * this function must be called once to get the object to

   353

     * reference the first element...

   354

     *

   355

     * Returns the element's name!

   356

     */

   357

    identifier_c *next(void) {

   358

      void *res;

   359

      identifier_c *identifier;

   360

      element_count = 0;

   361

      next_element++;

   362

      res = type_decl->accept(*this);

   363

      if (res != NULL) {

   364

        symbol_c *sym = (symbol_c *)res;

   365

        identifier = dynamic_cast<identifier_c *>(sym);

   366

        if (identifier == NULL)

   367

          ERROR;

   368

      }

   369

      else

   370

        return NULL;

   371

   372

      current_element_name = identifier;

   373

      return current_element_name;

   374

    }

   375

   376

    /* Returns the currently referenced element's default value,

   377

     * or NULL if none is specified in the structure declaration itself.

   378

     */

   379

    symbol_c *default_value(void) {

   380

      return current_element_default_value;

   381

    }

   382

   383

    /* Returns the currently referenced element's type name. */

   384

    symbol_c *element_type(void) {

   385

      return current_element_type;

   386

    }

   387

   388

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

   389

/* B 1.3.3 - Derived data types */

   390

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

   391

   392

    /* helper symbol for structure_declaration */

   393

    /* structure_element_declaration_list structure_element_declaration ';' */

   394

    void *visit(structure_element_declaration_list_c *symbol) {

   395

      void *res;

   396

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

   397

        res = symbol->elements[i]->accept(*this);

   398

        if (res != NULL)

   399

          return res;

   400

      }

   401

      return NULL;

   402

    }

   403

   404

    /*  structure_element_name ':' *_spec_init */

   405

    void *visit(structure_element_declaration_c *symbol) {

   406

      element_count++;

   407

      if (next_element == element_count) {

   408

        current_element_default_value = spec_init_sperator_c::get_init(symbol->spec_init);

   409

        current_element_type = spec_init_sperator_c::get_spec(symbol->spec_init);

   410

        return symbol->structure_element_name;

   411

      }

   412

      /* not yet the desired element... */

   413

      return NULL;

   414

    }

   415

   416

};

   417

   418

/*

   419

 * Structure init element iterator.

   420

 * It will search through the elements of a structure initialization

   421

 */

   422

class structure_init_element_iterator_c : public null_visitor_c {

   423

  private:

   424

    /* a pointer to the structure initialization

   425

     * currently being analysed.

   426

     */

   427

    symbol_c *structure_initialization;

   428

    identifier_c *search_element_name;

   429

   430

  public:

   431

    /* initialise the iterator object.

   432

     * We must be given a reference to the structure initialization

   433

     * that will be analysed...

   434

     */

   435

    structure_init_element_iterator_c(symbol_c *structure_initialization) {

   436

      this->structure_initialization = structure_initialization;

   437

      search_element_name = NULL;

   438

    }

   439

   440

    /* Search for the value passed to the element named <element_name>...  */

   441

    symbol_c *search(symbol_c *element_name) {

   442

      if (NULL == element_name) ERROR;

   443

      search_element_name = dynamic_cast<identifier_c *>(element_name);

   444

      if (NULL == search_element_name) ERROR;

   445

      void *res = structure_initialization->accept(*this);

   446

      return (symbol_c *)res;

   447

    }

   448

   449

    /* helper symbol for structure_initialization */

   450

    /* structure_element_initialization_list ',' structure_element_initialization */

   451

    void *visit(structure_element_initialization_list_c *symbol) {

   452

      void *res;

   453

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

   454

        res = symbol->elements[i]->accept(*this);

   455

        if (res != NULL)

   456

          return res;

   457

      }

   458

      return NULL;

   459

    }

   460

   461

    /*  structure_element_name ASSIGN value */

   462

    void *visit(structure_element_initialization_c *symbol) {

   463

      identifier_c *element_name = dynamic_cast<identifier_c *>(symbol->structure_element_name);

   464

   465

      if (element_name == NULL) ERROR;

   466

   467

      if (strcasecmp(search_element_name->value, element_name->value) == 0)

   468

        /* FOUND! This is the same element!! */

   469

        return (void *)symbol->value;

   470

      return NULL;

   471

    }

   472

};

   473

   474

class generate_c_structure_initialization_c: public generate_c_typedecl_c {

   475

   476

  public:

   477

    typedef enum {

   478

      none_sm,

   479

      initdefault_sm,

   480

      typedecl_sm,

   481

      initializationvalue_sm

   482

    } structureinitialization_mode_t;

   483

   484

    structureinitialization_mode_t current_mode;

   485

   486

  private:

   487

    symbol_c* structure_type_decl;

   488

    symbol_c* current_element_type;

   489

   490

  public:

   491

    generate_c_structure_initialization_c(stage4out_c *s4o_ptr): generate_c_typedecl_c(s4o_ptr) {}

   492