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

#include <limits>  // required for std::numeric_limits<XXX>

    26

    27

class initialization_analyzer_c: public null_visitor_c {

    28

  public:

    29

    typedef enum {

    30

      simple_it,

    31

      array_it,

    32

      struct_it

    33

    } initialization_type_t;

    34

    35

  private:

    36

    37

    initialization_type_t current_type;

    38

    39

  public:

    40

    initialization_analyzer_c(symbol_c* symbol) {

    41

      current_type = simple_it;

    42

      symbol->accept(*this);

    43

    }

    44

    ~initialization_analyzer_c(void) {}

    45

    46

    initialization_type_t get_initialization_type(void) {

    47

      return current_type;

    48

    }

    49

    50

    void *visit(array_initial_elements_list_c *symbol) {

    51

      current_type = array_it;

    52

      return NULL;

    53

    }

    54

    55

    void *visit(structure_element_initialization_list_c *symbol) {

    56

      current_type = struct_it;

    57

      return NULL;

    58

    }

    59

};

    60

    63

class generate_c_array_initialization_c: public generate_c_typedecl_c {

    64

    65

  public:

    66

    typedef enum {

    67

      none_am,

    68

      arraysize_am,

    69

      typedecl_am,

    70

      initializationvalue_am

    71

    } arrayinitialization_mode_t;

    72

    73

    arrayinitialization_mode_t current_mode;

    74

    75

    symbol_c* array_base_type;

    76

    symbol_c* array_default_value;

    77

    symbol_c* array_default_initialization;

    78

    79

  private:

    80

    int current_dimension;

    81

    unsigned long long int array_size;

    82

    unsigned long long int defined_values_count;

    83

    unsigned long long int current_initialization_count;

    84

    85

  public:

    86

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

    87

    ~generate_c_array_initialization_c(void) {}

    88

    89

    void init_array_size(symbol_c *array_specification) {

    90

      array_size = 1;

    91

      defined_values_count = 0;

    92

      current_initialization_count = 0;

    93

      array_base_type = array_default_value = array_default_initialization = NULL;

    94

    95

      current_mode = arraysize_am;

    96

      array_specification->accept(*this);

    97

    }

    98

    99

    void set_array_default_initialisation(symbol_c *array_initialization) {

   100

      array_default_initialization = array_initialization;

   101

    }

   102

   103

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

   104

      int i;

   105

   106

      init_array_size(array_specification);

   107

   108

      s4o.print("\n");

   109

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

   110

      s4o.indent_right();

   111

      s4o.print(s4o.indent_spaces);

   112

      s4o.print("static const ");

   113

   114

      current_mode = typedecl_am;

   115

      array_specification->accept(*this);

   116

      s4o.print(" temp = ");

   117

   118

      init_array_values(array_initialization);

   119

   120

      s4o.print(";\n");

   121

      var1_list->accept(*this);

   122

      s4o.indent_left();

   123

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

   124

    }

   125

   126

    void init_array_values(symbol_c *array_initialization) {

   127

      s4o.print("{{");

   128

   129

      current_mode = initializationvalue_am;

   130

      array_initialization->accept(*this);

   131

   132

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

   133

        array_default_initialization->accept(*this);

   134

      if (defined_values_count < array_size) {

   135

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

   136

          if (defined_values_count > 0)

   137

            s4o.print(",");

   138

          array_default_value->accept(*this);

   139

          defined_values_count++;

   140

        }

   141

      }

   142

   143

      s4o.print("}}");

   144

    }

   145

   146

    void *visit(identifier_c *type_name) {

   147

      symbol_c *type_decl;

   148

      switch (current_mode) {

   149

        case arraysize_am:

   150

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

   151

          type_decl = type_symtable.find_value(type_name);

   152

          if (type_decl == type_symtable.end_value())

   153

            /* Type declaration not found!! */

   154

            ERROR;

   155

          type_decl->accept(*this);

   156

          break;

   157

        default:

   158

          print_token(type_name);

   159

          break;

   160

      }

   161

      return NULL;

   162

    }

   163

   164

    void *visit(var1_list_c *symbol) {

   165

      int i, j;

   166

   167

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

   168

        s4o.print(s4o.indent_spaces);

   169

        s4o.print(SET_VAR);

   170

        s4o.print("(");

   171

        print_variable_prefix();

   172

        s4o.print(",");

   173

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

   174

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

   175

      }

   176

      return NULL;

   177

    }

   178

   179

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

   180

/* B 1.3.3 - Derived data types */

   181

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

   182

   183

    /* array_specification [ASSIGN array_initialization] */

   184

    /* array_initialization may be NULL ! */

   185

    void *visit(array_spec_init_c *symbol) {

   186

      switch (current_mode) {

   187

        case arraysize_am:

   188

          array_default_initialization = symbol->array_initialization;

   189

          break;

   190

        default:

   191

          break;

   192

      }

   193

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

   194

      return NULL;

   195

    }

   196

   197

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

   198

    void *visit(array_specification_c *symbol) {

   199

      identifier_c* type_name;

   200

      switch (current_mode) {

   201

        case arraysize_am:

   202

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

   203

          array_base_type = symbol->non_generic_type_name;

   204

          array_default_value = type_initial_value_c::get(symbol->non_generic_type_name);

   205

          if (array_default_value == NULL) ERROR;

   206

          break;

   219

        default:

   220

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

   221

          break;

   222

      } 

   223

      return NULL;

   224

    }

   225

   226

    /*  signed_integer DOTDOT signed_integer */

   227

    //SYM_REF2(subrange_c, lower_limit, upper_limit)

   228

    void *visit(subrange_c *symbol) {

   229

      switch (current_mode) {

   230

        case arraysize_am:

   231

          /* res = a * b; --->  Check for overflow by pre-condition: If (UINT_MAX / a) < b => overflow! */

   232

          if ((std::numeric_limits< unsigned long long int >::max() / array_size) < symbol->dimension)

   233

            STAGE4_ERROR(symbol, symbol, "The array containing this subrange has a total number of elements larger than the maximum currently supported (%llu).", 

   234

                         std::numeric_limits< unsigned long long int >::max());

   235

          array_size *= symbol->dimension;

   236

          break;

   237

        default:

   238

          break;

   239

      }

   240

      return NULL;

   241

    }

   242

   243

    /* helper symbol for array_initialization */

   244

    /* array_initial_elements_list ',' array_initial_elements */

   245

    void *visit(array_initial_elements_list_c *symbol) {

   246

      switch (current_mode) {

   247

        case initializationvalue_am:

   248

          current_initialization_count = 0;

   249

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

   250

            if (current_initialization_count >= defined_values_count) {

   251

              if (defined_values_count >= array_size)

   252

                ERROR;

   253

              if (defined_values_count > 0)

   254

                s4o.print(",");

   255

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

   256

              defined_values_count++;

   257

            }

   258

            else {

   259

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

   260

   261

              if (array_initial_element != NULL) {

   262

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

   263

              }

   264

            }

   265

            current_initialization_count++;

   266

          }

   267

          break;

   268

        default:

   269

          break;

   270

      }

   271

      return NULL;

   272

    }

   273

   274

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

   275

    /* array_initial_element may be NULL ! */

   276

    void *visit(array_initial_elements_c *symbol) {

   277

      unsigned long long int initial_element_count;

   278

   279

      /* This code assumes that unsigned long long int is >= uint64_t */

   280

      if (std::numeric_limits< uint64_t >::max() > std::numeric_limits< unsigned long long int >::max()) 

   281

        ERROR_MSG("Assertion (sizeof(uint64_t) > sizeof(unsigned long long int)) failed! Compiler cannot execute correctly on the current platform!");

   282

   283

      switch (current_mode) {

   284

        case initializationvalue_am:

   285

          if      (VALID_CVALUE( int64, symbol->integer) && (GET_CVALUE( int64, symbol->integer) >= 0))

   286

            initial_element_count = GET_CVALUE( int64, symbol->integer);

   287

          else if (VALID_CVALUE(uint64, symbol->integer))

   288

            initial_element_count = GET_CVALUE(uint64, symbol->integer);

   289

          else ERROR;

   290

   291

          if (current_initialization_count < defined_values_count) {

   292

            unsigned long long int temp_element_number = 0;

   293

            unsigned long long int diff = defined_values_count - current_initialization_count;

   294

            if (diff <= initial_element_count)

   295

              temp_element_number = initial_element_count - diff;

   296

            current_initialization_count += initial_element_count - 1;

   297

            initial_element_count = temp_element_number;

   298

            if (initial_element_count > 0) {

   299

              defined_values_count++;

   300

              s4o.print(",");

   301

            }

   302

          }

   303

          else

   304

            current_initialization_count += initial_element_count - 1;

   305

          if (defined_values_count + initial_element_count > array_size)

   306

            ERROR;

   307

          for (unsigned long long int i = 0; i < initial_element_count; i++) {

   308

            if (i > 0)

   309

              s4o.print(",");

   310

            if (symbol->array_initial_element != NULL) {

   311

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

   312

            }

   313

            else {

   314

              array_default_value->accept(*this);

   315

            }

   316

          }

   317

          if (initial_element_count > 1)

   318

            defined_values_count += initial_element_count - 1;

   319

          break;

   320

        default:

   321

          break;

   322

      }

   323

      return NULL;

   324

    }

   325

   326

    void *visit(structure_element_initialization_list_c *symbol);

   327

};

   328

   329

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

   330

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

   331

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

   332

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

   333

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

   334

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

   335

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

   336

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

   337

   338

/* given a structure_element_declaration_list_c, iterate 

   339

 * through each element, returning the name

   340

 * of each element...structure_element_iterator_c

   341

 */

   342

class structure_element_iterator_c : public null_visitor_c {

   343

   344

  private:

   345

    /* a pointer to the structure_element_declaration_list_c

   346

     * currently being analysed.

   347

     */

   348

    symbol_c *type_decl;

   349

    int next_element, element_count;

   350

    identifier_c *current_element_name;

   351

    symbol_c *current_element_type;

   352

    symbol_c *current_element_default_value;

   353

   354

   355

  public:

   356

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

   357

    void reset(void) {

   358

      next_element = element_count = 0;

   359

      current_element_name = NULL;

   360

      current_element_type = current_element_default_value = NULL;

   361

    }

   362

   363

    /* initialise the iterator object.

   364

     * We must be given a reference to the function declaration

   365

     * that will be analysed...

   366

     */

   367

    structure_element_iterator_c(symbol_c *type_decl) {

   368

      this->type_decl = type_decl;

   369

      reset();

   370

    }

   371

   372

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

   373

     * the object references on 

   374

     * element _before_ the first, so

   375

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

   376

     * reference the first element...

   377

     *

   378

     * Returns the element's name!

   379

     */

   380

    identifier_c *next(void) {

   381

      void *res;

   382

      identifier_c *identifier;

   383

      element_count = 0;

   384

      next_element++;

   385

      res = type_decl->accept(*this);

   386

      if (res != NULL) {

   387

        symbol_c *sym = (symbol_c *)res;

   388

        identifier = dynamic_cast<identifier_c *>(sym);

   389

        if (identifier == NULL)

   390

          ERROR;

   391

      }

   392

      else

   393

        return NULL;

   394

   395

      current_element_name = identifier;

   396

      return current_element_name;

   397

    }

   398

   399

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

   400

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

   401

     */

   402

    symbol_c *default_value(void) {

   403

      return current_element_default_value;

   404

    }

   405

   406

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

   407

    symbol_c *element_type(void) {

   408

      return current_element_type;

   409

    }

   410

   411

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

   412

/* B 1.3.3 - Derived data types */

   413

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

   414

   415

    /* helper symbol for structure_declaration */

   416

    /* structure_element_declaration_list structure_element_declaration ';' */

   417

    void *visit(structure_element_declaration_list_c *symbol) {

   418

      void *res;

   419

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

   420

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

   421

        if (res != NULL)

   422

          return res;

   423

      }

   424

      return NULL;

   425

    }

   426

   427

    /*  structure_element_name ':' *_spec_init */

   428

    void *visit(structure_element_declaration_c *symbol) {

   429

      element_count++;

   430

      if (next_element == element_count) {

   431

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

   432

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

   433

        if (current_element_type == NULL) ERROR;

   434

        return symbol->structure_element_name;

   435

      }

   436

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

   437

      return NULL;

   438

    }

   439

   440

};

   441

   442

/*

   443

 * Structure init element iterator.

   444

 * It will search through the elements of a structure initialization

   445

 */

   446

class structure_init_element_iterator_c : public null_visitor_c {

   447

  private:

   448

    /* a pointer to the structure initialization

   449

     * currently being analysed.

   450

     */

   451

    symbol_c *structure_initialization;

   452

    identifier_c *search_element_name;

   453

   454

  public:

   455

    /* initialise the iterator object.

   456

     * We must be given a reference to the structure initialization

   457

     * that will be analysed...

   458

     */

   459

    structure_init_element_iterator_c(symbol_c *structure_initialization) {

   460

      this->structure_initialization = structure_initialization;

   461

      search_element_name = NULL;

   462

    }

   463

   464

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

   465

    symbol_c *search(symbol_c *element_name) {

   466

      if (NULL == element_name) ERROR;

   467

      search_element_name = dynamic_cast<identifier_c *>(element_name);

   468

      if (NULL == search_element_name) ERROR;

   469

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

   470

      return (symbol_c *)res;

   471

    }

   472

   473

    /* helper symbol for structure_initialization */

   474

    /* structure_element_initialization_list ',' structure_element_initialization */

   475

    void *visit(structure_element_initialization_list_c *symbol) {

   476

      void *res;

   477

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

   478

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

   479

        if (res != NULL)

   480

          return res;

   481

      }

   482

      return NULL;

   483

    }

   484

   485

    /*  structure_element_name ASSIGN value */

   486

    void *visit(structure_element_initialization_c *symbol) {

   487

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

   488

   489

      if (element_name == NULL) ERROR;

   490