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

    61

class generate_c_array_initialization_c: public generate_c_typedecl_c {

    62

    63

  public:

    64

    typedef enum {

    65

      none_am,

    66

      arraysize_am,

    67

      typedecl_am,

    68

      initializationvalue_am

    69

    } arrayinitialization_mode_t;

    70

    71

    arrayinitialization_mode_t current_mode;

    72

    73

    symbol_c* array_base_type;

    74

    symbol_c* array_default_value;

    75

    symbol_c* array_default_initialization;

    76

    77

  private:

    78

    int current_dimension;

    79

    unsigned long long int array_size;

    80

    unsigned long long int defined_values_count;

    81

    unsigned long long int current_initialization_count;

    82

    83

  public:

    84

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

    85

    ~generate_c_array_initialization_c(void) {}

    86

    87

    void init_array_size(symbol_c *array_specification) {

    88

      array_size = 1;

    89

      defined_values_count = 0;

    90

      current_initialization_count = 0;

    91

      array_base_type = array_default_value = array_default_initialization = NULL;

    92

    93

      current_mode = arraysize_am;

    94

      array_specification->accept(*this);

    95

    }

    96

    97

    void set_array_default_initialisation(symbol_c *array_initialization) {

    98

      array_default_initialization = array_initialization;

    99

    }

   100

   101

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

   102

      int i;

   103

   104

      init_array_size(array_specification);

   105

   106

      s4o.print("\n");

   107

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

   108

      s4o.indent_right();

   109

      s4o.print(s4o.indent_spaces);

   110

      s4o.print("static const ");

   111

   112

      current_mode = typedecl_am;

   113

      array_specification->accept(*this);

   114

      s4o.print(" temp = ");

   115

   116

      init_array_values(array_initialization);

   117

   118

      s4o.print(";\n");

   119

      var1_list->accept(*this);

   120

      s4o.indent_left();

   121

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

   122

    }

   123

   124

    void init_array_values(symbol_c *array_initialization) {

   125

      s4o.print("{{");

   126

   127

      current_mode = initializationvalue_am;

   128

      array_initialization->accept(*this);

   129

   130

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

   131

        array_default_initialization->accept(*this);

   132

      if (defined_values_count < array_size) {

   133

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

   134

          if (defined_values_count > 0)

   135

            s4o.print(",");

   136

          array_default_value->accept(*this);

   137

          defined_values_count++;

   138

        }

   139

      }

   140

   141

      s4o.print("}}");

   142

    }

   143

   144

    void *visit(identifier_c *type_name) {

   145

      symbol_c *type_decl;

   146

      switch (current_mode) {

   147

        case arraysize_am:

   148

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

   149

          type_decl = type_symtable.find_value(type_name);

   150

          if (type_decl == type_symtable.end_value())

   151

            /* Type declaration not found!! */

   152

            ERROR;

   153

          type_decl->accept(*this);

   154

          break;

   155

        default:

   156

          print_token(type_name);

   157

          break;

   158

      }

   159

      return NULL;

   160

    }

   161

   162

    void *visit(var1_list_c *symbol) {

   163

      int i, j;

   164

   165

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

   166

        s4o.print(s4o.indent_spaces);

   167

        s4o.print(SET_VAR);

   168

        s4o.print("(");

   169

        print_variable_prefix();

   170

        s4o.print(",");

   171

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

   172

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

   173

      }

   174

      return NULL;

   175

    }

   176

   177

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

   178

/* B 1.3.3 - Derived data types */

   179

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

   180

   181

    /* array_specification [ASSIGN array_initialization] */

   182

    /* array_initialization may be NULL ! */

   183

    void *visit(array_spec_init_c *symbol) {

   184

      switch (current_mode) {

   185

        case arraysize_am:

   186

          array_default_initialization = symbol->array_initialization;

   187

          break;

   188

        default:

   189

          break;

   190

      }

   191

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

   192

      return NULL;

   193

    }

   194

   195

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

   196

    void *visit(array_specification_c *symbol) {

   197

      identifier_c* type_name;

   198

      switch (current_mode) {

   199

        case arraysize_am:

   200

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

   201

          array_base_type = symbol->non_generic_type_name;

   202

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

   203

          if (array_default_value == NULL) ERROR;

   204

          break;

   205

        case typedecl_am:

   206

          s4o.print("__");

   207

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

   208

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

   209

          break;

   210

        default:

   211

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

   212

          break;

   213

      } 

   214

      return NULL;

   215

    }

   216

   217

    /*  signed_integer DOTDOT signed_integer */

   218

    //SYM_REF2(subrange_c, lower_limit, upper_limit)

   219

    void *visit(subrange_c *symbol) {

   220

      switch (current_mode) {

   221

        case arraysize_am:

   222

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

   223

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

   224

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

   225

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

   226

          array_size *= symbol->dimension;

   227

          break;

   228

        case typedecl_am:

   229

          s4o.print("_");

   230

          s4o.print(symbol->dimension);

   231

          break;

   232

        default:

   233

          break;

   234

      }

   235

      return NULL;

   236

    }

   237

   238

    /* helper symbol for array_initialization */

   239

    /* array_initial_elements_list ',' array_initial_elements */

   240

    void *visit(array_initial_elements_list_c *symbol) {

   241

      switch (current_mode) {

   242

        case initializationvalue_am:

   243

          current_initialization_count = 0;

   244

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

   245

            if (current_initialization_count >= defined_values_count) {

   246

              if (defined_values_count >= array_size)

   247

                ERROR;

   248

              if (defined_values_count > 0)

   249

                s4o.print(",");

   250

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

   251

              defined_values_count++;

   252

            }

   253

            else {

   254

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

   255

   256

              if (array_initial_element != NULL) {

   257

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

   258

              }

   259

            }

   260

            current_initialization_count++;

   261

          }

   262

          break;

   263

        default:

   264

          break;

   265

      }

   266

      return NULL;

   267

    }

   268

   269

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

   270

    /* array_initial_element may be NULL ! */

   271

    void *visit(array_initial_elements_c *symbol) {

   272

      unsigned long long int initial_element_count;

   273

   274

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

   275

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

   276

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

   277

   278

      switch (current_mode) {

   279

        case initializationvalue_am:

   280

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

   281

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

   282

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

   283

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

   284

          else ERROR;

   285

   286

          if (current_initialization_count < defined_values_count) {

   287

            unsigned long long int temp_element_number = 0;

   288

            unsigned long long int diff = defined_values_count - current_initialization_count;

   289

            if (diff <= initial_element_count)

   290

              temp_element_number = initial_element_count - diff;

   291

            current_initialization_count += initial_element_count - 1;

   292

            initial_element_count = temp_element_number;

   293

            if (initial_element_count > 0) {

   294

              defined_values_count++;

   295

              s4o.print(",");

   296

            }

   297

          }

   298

          else

   299

            current_initialization_count += initial_element_count - 1;

   300

          if (defined_values_count + initial_element_count > array_size)

   301

            ERROR;

   302

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

   303

            if (i > 0)

   304

              s4o.print(",");

   305

            if (symbol->array_initial_element != NULL) {

   306

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

   307

            }

   308

            else {

   309

              array_default_value->accept(*this);

   310

            }

   311

          }

   312

          if (initial_element_count > 1)

   313

            defined_values_count += initial_element_count - 1;

   314

          break;

   315

        default:

   316

          break;

   317

      }

   318

      return NULL;

   319

    }

   320

   321

    void *visit(structure_element_initialization_list_c *symbol);

   322

};

   323

   324

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

   325

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

   326

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

   327

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

   328

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

   329

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

   330

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

   331

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

   332

   333

/* given a structure_element_declaration_list_c, iterate 

   334

 * through each element, returning the name

   335

 * of each element...structure_element_iterator_c

   336

 */

   337

class structure_element_iterator_c : public null_visitor_c {

   338

   339

  private:

   340

    /* a pointer to the structure_element_declaration_list_c

   341

     * currently being analysed.

   342

     */

   343

    symbol_c *type_decl;

   344

    int next_element, element_count;

   345

    identifier_c *current_element_name;

   346

    symbol_c *current_element_type;

   347

    symbol_c *current_element_default_value;

   348

   349

   350

  public:

   351

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

   352

    void reset(void) {

   353

      next_element = element_count = 0;

   354

      current_element_name = NULL;

   355

      current_element_type = current_element_default_value = NULL;

   356

    }

   357

   358

    /* initialise the iterator object.

   359

     * We must be given a reference to the function declaration

   360

     * that will be analysed...

   361

     */

   362

    structure_element_iterator_c(symbol_c *type_decl) {

   363

      this->type_decl = type_decl;

   364

      reset();

   365

    }

   366

   367

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

   368

     * the object references on 

   369

     * element _before_ the first, so

   370

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

   371

     * reference the first element...

   372

     *

   373

     * Returns the element's name!

   374

     */

   375

    identifier_c *next(void) {

   376

      void *res;

   377

      identifier_c *identifier;

   378

      element_count = 0;

   379

      next_element++;

   380

      res = type_decl->accept(*this);

   381

      if (res != NULL) {

   382

        symbol_c *sym = (symbol_c *)res;

   383

        identifier = dynamic_cast<identifier_c *>(sym);

   384

        if (identifier == NULL)

   385

          ERROR;

   386

      }

   387

      else

   388

        return NULL;

   389

   390

      current_element_name = identifier;

   391

      return current_element_name;

   392

    }

   393

   394

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

   395

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

   396

     */

   397

    symbol_c *default_value(void) {

   398

      return current_element_default_value;

   399

    }

   400

   401

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

   402

    symbol_c *element_type(void) {

   403

      return current_element_type;

   404

    }

   405

   406

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

   407

/* B 1.3.3 - Derived data types */

   408

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

   409

   410

    /* helper symbol for structure_declaration */

   411

    /* structure_element_declaration_list structure_element_declaration ';' */

   412

    void *visit(structure_element_declaration_list_c *symbol) {

   413

      void *res;

   414

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

   415

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

   416

        if (res != NULL)

   417

          return res;

   418

      }

   419

      return NULL;

   420

    }

   421

   422

    /*  structure_element_name ':' *_spec_init */

   423

    void *visit(structure_element_declaration_c *symbol) {

   424

      element_count++;

   425

      if (next_element == element_count) {

   426

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

   427

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

   428

        if (current_element_type == NULL) ERROR;

   429

        return symbol->structure_element_name;

   430

      }

   431

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

   432

      return NULL;

   433

    }

   434

   435

};

   436

   437

/*

   438

 * Structure init element iterator.

   439

 * It will search through the elements of a structure initialization

   440

 */

   441

class structure_init_element_iterator_c : public null_visitor_c {

   442

  private:

   443

    /* a pointer to the structure initialization

   444

     * currently being analysed.

   445

     */

   446

    symbol_c *structure_initialization;

   447

    identifier_c *search_element_name;

   448

   449

  public:

   450

    /* initialise the iterator object.

   451

     * We must be given a reference to the structure initialization

   452

     * that will be analysed...

   453

     */

   454

    structure_init_element_iterator_c(symbol_c *structure_initialization) {

   455

      this->structure_initialization = structure_initialization;

   456

      search_element_name = NULL;

   457

    }

   458

   459

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

   460

    symbol_c *search(symbol_c *element_name) {

   461

      if (NULL == element_name) ERROR;

   462

      search_element_name = dynamic_cast<identifier_c *>(element_name);

   463

      if (NULL == search_element_name) ERROR;

   464

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

   465

      return (symbol_c *)res;

   466

    }

   467

   468

    /* helper symbol for structure_initialization */

   469

    /* structure_element_initialization_list ',' structure_element_initialization */

   470

    void *visit(structure_element_initialization_list_c *symbol) {

   471

      void *res;

   472

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

   473

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

   474

        if (res != NULL)

   475

          return res;

   476

      }

   477

      return NULL;

   478

    }

   479

   480

    /*  structure_element_name ASSIGN value */

   481

    void *visit(structure_element_initialization_c *symbol) {

   482

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

   483

   484

      if (element_name == NULL) ERROR;

   485

   486

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

   487

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

   488

        return (void *)symbol->value;

   489

      return NULL;

   490

    }