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 init_array(symbol_c *var1_list, symbol_c *array_specification, symbol_c *array_initialization) {

    98

      int i;

    99

   100

      init_array_size(array_specification);

   101

   102

      s4o.print("\n");

   103

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

   104

      s4o.indent_right();

   105

      s4o.print(s4o.indent_spaces);

   106

      s4o.print("static const ");

   107

   108

      current_mode = typedecl_am;

   109

      array_specification->accept(*this);

   110

      s4o.print(" temp = ");

   111

   112

      init_array_values(array_initialization);

   113

   114

      s4o.print(";\n");

   115

      var1_list->accept(*this);

   116

      s4o.indent_left();

   117

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

   118

    }

   119

   120

    void init_array_values(symbol_c *array_initialization) {

   121

      s4o.print("{{");

   122

   123

      current_mode = initializationvalue_am;

   124

      array_initialization->accept(*this);

   125

   126

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

   127

        array_default_initialization->accept(*this);

   128

      if (defined_values_count < array_size) {

   129

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

   130

          if (defined_values_count > 0)

   131

            s4o.print(",");

   132

          array_default_value->accept(*this);

   133

          defined_values_count++;

   134

        }

   135

      }

   136

   137

      s4o.print("}}");

   138

    }

   139

   140

    void *visit(identifier_c *type_name) {

   141

      symbol_c *type_decl;

   142

      switch (current_mode) {

   143

        case arraysize_am:

   144

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

   145

          type_decl = type_symtable.find_value(type_name);

   146

          if (type_decl == type_symtable.end_value())

   147

            /* Type declaration not found!! */

   148

            ERROR;

   149

          type_decl->accept(*this);

   150

          break;

   151

        default:

   152

          print_token(type_name);

   153

          break;

   154

      }

   155

      return NULL;

   156

    }

   157

   158

    void *visit(var1_list_c *symbol) {

   159

      int i, j;

   160

   161

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

   162

        s4o.print(s4o.indent_spaces);

   163

        s4o.print(SET_VAR);

   164

        s4o.print("(");

   165

        print_variable_prefix();

   166

        s4o.print(",");

   167

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

   168

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

   169

      }

   170

      return NULL;

   171

    }

   172

   173

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

   174

/* B 1.3.3 - Derived data types */

   175

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

   176

   177

    /* array_specification [ASSIGN array_initialization] */

   178

    /* array_initialization may be NULL ! */

   179

    void *visit(array_spec_init_c *symbol) {

   180

      switch (current_mode) {

   181

        case arraysize_am:

   182

          array_default_initialization = symbol->array_initialization;

   183

          break;

   184

        default:

   185

          break;

   186

      }

   187

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

   188

      return NULL;

   189

    }

   190

   191

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

   192

    void *visit(array_specification_c *symbol) {

   193

      identifier_c* type_name;

   194

      switch (current_mode) {

   195

        case arraysize_am:

   196

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

   197

          array_base_type = symbol->non_generic_type_name;

   198

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

   199

          if (array_default_value == NULL) ERROR;

   200

          break;

   201

        case typedecl_am:

   202

          s4o.print("__");

   203

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

   204

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

   205

          break;

   206

        default:

   207

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

   208

          break;

   209

      } 

   210

      return NULL;

   211

    }

   212

   213

    /*  signed_integer DOTDOT signed_integer */

   214

    //SYM_REF2(subrange_c, lower_limit, upper_limit)

   215

    void *visit(subrange_c *symbol) {

   216

      switch (current_mode) {

   217

        case arraysize_am:

   218

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

   219

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

   220

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

   221

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

   222

          array_size *= symbol->dimension;

   223

          break;

   224

        case typedecl_am:

   225

          s4o.print("_");

   226

          s4o.print(symbol->dimension);

   227

          break;

   228

        default:

   229

          break;

   230

      }

   231

      return NULL;

   232

    }

   233

   234

    /* helper symbol for array_initialization */

   235

    /* array_initial_elements_list ',' array_initial_elements */

   236

    void *visit(array_initial_elements_list_c *symbol) {

   237

      switch (current_mode) {

   238

        case initializationvalue_am:

   239

          current_initialization_count = 0;

   240

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

   241

            if (current_initialization_count >= defined_values_count) {

   242

              if (defined_values_count >= array_size)

   243

                ERROR;

   244

              if (defined_values_count > 0)

   245

                s4o.print(",");

   246

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

   247

              defined_values_count++;

   248

            }

   249

            else {

   250

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

   251

   252

              if (array_initial_element != NULL) {

   253

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

   254

              }

   255

            }

   256

            current_initialization_count++;

   257

          }

   258

          break;

   259

        default:

   260

          break;

   261

      }

   262

      return NULL;

   263

    }

   264

   265

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

   266

    /* array_initial_element may be NULL ! */

   267

    void *visit(array_initial_elements_c *symbol) {

   268

      unsigned long long int initial_element_count;

   269

   270

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

   271

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

   272

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

   273

   274

      switch (current_mode) {

   275

        case initializationvalue_am:

   276

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

   277

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

   278

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

   279

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

   280

          else ERROR;

   281

   282

          if (current_initialization_count < defined_values_count) {

   283

            unsigned long long int temp_element_number = 0;

   284

            unsigned long long int diff = defined_values_count - current_initialization_count;

   285

            if (diff <= initial_element_count)

   286

              temp_element_number = initial_element_count - diff;

   287

            current_initialization_count += initial_element_count - 1;

   288

            initial_element_count = temp_element_number;

   289

            if (initial_element_count > 0) {

   290

              defined_values_count++;

   291

              s4o.print(",");

   292

            }

   293

          }

   294

          else

   295

            current_initialization_count += initial_element_count - 1;

   296

          if (defined_values_count + initial_element_count > array_size)

   297

            ERROR;

   298

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

   299

            if (i > 0)

   300

              s4o.print(",");

   301

            if (symbol->array_initial_element != NULL) {

   302

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

   303

            }

   304

            else {

   305

              array_default_value->accept(*this);

   306

            }

   307

          }

   308

          if (initial_element_count > 1)

   309

            defined_values_count += initial_element_count - 1;

   310

          break;

   311

        default:

   312

          break;

   313

      }

   314

      return NULL;

   315

    }

   316

   317

    void *visit(structure_element_initialization_list_c *symbol);

   318

};

   319

   320

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

   321

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

   322

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

   323

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

   324

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

   325

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

   326

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

   327

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

   328

   329

/* given a structure_element_declaration_list_c, iterate 

   330

 * through each element, returning the name

   331

 * of each element...structure_element_iterator_c

   332

 */

   333

class structure_element_iterator_c : public null_visitor_c {

   334

   335

  private:

   336

    /* a pointer to the structure_element_declaration_list_c

   337

     * currently being analysed.

   338

     */

   339

    symbol_c *type_decl;

   340

    int next_element, element_count;

   341

    identifier_c *current_element_name;

   342

    symbol_c *current_element_type;

   343

    symbol_c *current_element_default_value;

   344

   345

   346

  public:

   347

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

   348

    void reset(void) {

   349

      next_element = element_count = 0;

   350

      current_element_name = NULL;

   351

      current_element_type = current_element_default_value = NULL;

   352

    }

   353

   354

    /* initialise the iterator object.

   355

     * We must be given a reference to the function declaration

   356

     * that will be analysed...

   357

     */

   358

    structure_element_iterator_c(symbol_c *type_decl) {

   359

      this->type_decl = type_decl;

   360

      reset();

   361

    }

   362

   363

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

   364

     * the object references on 

   365

     * element _before_ the first, so

   366

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

   367

     * reference the first element...

   368

     *

   369

     * Returns the element's name!

   370

     */

   371

    identifier_c *next(void) {

   372

      void *res;

   373

      identifier_c *identifier;

   374

      element_count = 0;

   375

      next_element++;

   376

      res = type_decl->accept(*this);

   377

      if (res != NULL) {

   378

        symbol_c *sym = (symbol_c *)res;

   379

        identifier = dynamic_cast<identifier_c *>(sym);

   380

        if (identifier == NULL)

   381

          ERROR;

   382

      }

   383

      else

   384

        return NULL;

   385

   386

      current_element_name = identifier;

   387

      return current_element_name;

   388

    }

   389

   390

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

   391

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

   392

     */

   393

    symbol_c *default_value(void) {

   394

      return current_element_default_value;

   395

    }

   396

   397

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

   398

    symbol_c *element_type(void) {

   399

      return current_element_type;

   400

    }

   401

   402

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

   403

/* B 1.3.3 - Derived data types */

   404

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

   405

   406

    /* helper symbol for structure_declaration */

   407

    /* structure_element_declaration_list structure_element_declaration ';' */

   408

    void *visit(structure_element_declaration_list_c *symbol) {

   409

      void *res;

   410

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

   411

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

   412

        if (res != NULL)

   413

          return res;

   414

      }

   415

      return NULL;

   416

    }

   417

   418

    /*  structure_element_name ':' *_spec_init */

   419

    void *visit(structure_element_declaration_c *symbol) {

   420

      element_count++;

   421

      if (next_element == element_count) {

   422

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

   423

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

   424

        return symbol->structure_element_name;

   425

      }

   426

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

   427

      return NULL;

   428

    }

   429

   430

};

   431

   432

/*

   433

 * Structure init element iterator.

   434

 * It will search through the elements of a structure initialization

   435

 */

   436

class structure_init_element_iterator_c : public null_visitor_c {

   437

  private:

   438

    /* a pointer to the structure initialization

   439

     * currently being analysed.

   440

     */

   441

    symbol_c *structure_initialization;

   442

    identifier_c *search_element_name;

   443

   444

  public:

   445

    /* initialise the iterator object.

   446

     * We must be given a reference to the structure initialization

   447

     * that will be analysed...

   448

     */

   449

    structure_init_element_iterator_c(symbol_c *structure_initialization) {

   450

      this->structure_initialization = structure_initialization;

   451

      search_element_name = NULL;

   452

    }

   453

   454

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

   455

    symbol_c *search(symbol_c *element_name) {

   456

      if (NULL == element_name) ERROR;

   457

      search_element_name = dynamic_cast<identifier_c *>(element_name);

   458

      if (NULL == search_element_name) ERROR;

   459

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

   460

      return (symbol_c *)res;

   461

    }

   462

   463

    /* helper symbol for structure_initialization */

   464

    /* structure_element_initialization_list ',' structure_element_initialization */

   465

    void *visit(structure_element_initialization_list_c *symbol) {

   466

      void *res;

   467

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

   468

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

   469

        if (res != NULL)

   470

          return res;

   471

      }

   472

      return NULL;

   473

    }

   474

   475

    /*  structure_element_name ASSIGN value */

   476

    void *visit(structure_element_initialization_c *symbol) {

   477

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

   478

   479

      if (element_name == NULL) ERROR;

   480

   481

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

   482

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

   483

        return (void *)symbol->value;

   484

      return NULL;

   485

    }

   486

};

   487

   488

class generate_c_structure_initialization_c: public generate_c_typedecl_c {

   489

   490

  public:

   491

    typedef enum {