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

    63

class generate_c_array_initialization_c: public generate_c_base_and_typeid_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_base_and_typeid_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())   ERROR;  // Type declaration not found!!

   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

      switch (current_mode) {

   198

        case arraysize_am:

   199

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

   200

          array_base_type = symbol->non_generic_type_name;

   201

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

   202

          if (array_default_value == NULL) ERROR;

   203

          break;

   204

        case typedecl_am: {

   205

            int implicit_id_count = symbol->anotations_map.count("generate_c_annotaton__implicit_type_id");

   206

            if (implicit_id_count  > 1) ERROR;

   207

            if (implicit_id_count == 1)

   208

                /* this is part of an implicitly declared datatype (i.e. inside a variable decaration), for which an equivalent C datatype

   209

                 * has already been defined. So, we simly print out the id of that C datatpe...

   210

                 */

   211

              symbol->anotations_map["generate_c_annotaton__implicit_type_id"]->accept(*this);

   212

            else

   213

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

   214

            break;

   215

          }

   216

        default:

   217

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

   218

          break;

   219

      } 

   220

      return NULL;

   221

    }

   222

   223

    /*  signed_integer DOTDOT signed_integer */

   224

    //SYM_REF2(subrange_c, lower_limit, upper_limit)

   225

    void *visit(subrange_c *symbol) {

   226

      switch (current_mode) {

   227

        case arraysize_am:

   228

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

   229

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

   230

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

   231

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

   232

          array_size *= symbol->dimension;

   233

          break;

   234

        default:

   235

          break;

   236

      }

   237

      return NULL;

   238

    }

   239

   240

    /* helper symbol for array_initialization */

   241

    /* array_initial_elements_list ',' array_initial_elements */

   242

    void *visit(array_initial_elements_list_c *symbol) {

   243

      switch (current_mode) {

   244

        case initializationvalue_am:

   245

          current_initialization_count = 0;

   246

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

   247

            if (current_initialization_count >= defined_values_count) {

   248

              if (defined_values_count >= array_size)

   249

                ERROR;

   250

              if (defined_values_count > 0)

   251

                s4o.print(",");

   252

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

   253

              defined_values_count++;

   254

            }

   255

            else {

   256

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

   257

   258

              if (array_initial_element != NULL) {

   259

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

   260

              }

   261

            }

   262

            current_initialization_count++;

   263

          }

   264

          break;

   265

        default:

   266

          break;

   267

      }

   268

      return NULL;

   269

    }

   270

   271

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

   272

    /* array_initial_element may be NULL ! */

   273

    void *visit(array_initial_elements_c *symbol) {

   274

      unsigned long long int initial_element_count;

   275

   276

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

   277

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

   278

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

   279

   280

      switch (current_mode) {

   281

        case initializationvalue_am:

   282

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

   283

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

   284

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

   285

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

   286

          else ERROR;

   287

   288

          if (current_initialization_count < defined_values_count) {

   289

            unsigned long long int temp_element_number = 0;

   290

            unsigned long long int diff = defined_values_count - current_initialization_count;

   291

            if (diff <= initial_element_count)

   292

              temp_element_number = initial_element_count - diff;

   293

            current_initialization_count += initial_element_count - 1;

   294

            initial_element_count = temp_element_number;

   295

            if (initial_element_count > 0) {

   296

              defined_values_count++;

   297

              s4o.print(",");

   298

            }

   299

          }

   300

          else

   301

            current_initialization_count += initial_element_count - 1;

   302

          if (defined_values_count + initial_element_count > array_size)

   303

            ERROR;

   304

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

   305

            if (i > 0)

   306

              s4o.print(",");

   307

            if (symbol->array_initial_element != NULL) {

   308

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

   309

            }

   310

            else {

   311

              array_default_value->accept(*this);

   312

            }

   313

          }

   314

          if (initial_element_count > 1)

   315

            defined_values_count += initial_element_count - 1;

   316

          break;

   317

        default:

   318

          break;

   319

      }

   320

      return NULL;

   321

    }

   322

   323

    void *visit(structure_element_initialization_list_c *symbol);

   324

};

   325

   326

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

   327

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

   328

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

   329

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

   330

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

   331

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

   332

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

   333

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

   334

   335

/* given a structure_element_declaration_list_c, iterate 

   336

 * through each element, returning the name

   337

 * of each element...structure_element_iterator_c

   338

 */

   339

class structure_element_iterator_c : public null_visitor_c {

   340

   341

  private:

   342

    /* a pointer to the structure_element_declaration_list_c

   343

     * currently being analysed.

   344

     */

   345

    symbol_c *type_decl;

   346

    int next_element, element_count;

   347

    identifier_c *current_element_name;

   348

    symbol_c *current_element_type;

   349

    symbol_c *current_element_default_value;

   350

   351

   352

  public:

   353

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

   354

    void reset(void) {

   355

      next_element = element_count = 0;

   356

      current_element_name = NULL;

   357

      current_element_type = current_element_default_value = NULL;

   358

    }

   359

   360

    /* initialise the iterator object.

   361

     * We must be given a reference to the function declaration

   362

     * that will be analysed...

   363

     */

   364

    structure_element_iterator_c(symbol_c *type_decl) {

   365

      this->type_decl = type_decl;

   366

      reset();

   367

    }

   368

   369

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

   370

     * the object references on 

   371

     * element _before_ the first, so

   372

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

   373

     * reference the first element...

   374

     *

   375

     * Returns the element's name!

   376

     */

   377

    identifier_c *next(void) {

   378

      void *res;

   379

      identifier_c *identifier;

   380

      element_count = 0;

   381

      next_element++;

   382

      res = type_decl->accept(*this);

   383

      if (res != NULL) {

   384

        symbol_c *sym = (symbol_c *)res;

   385

        identifier = dynamic_cast<identifier_c *>(sym);

   386

        if (identifier == NULL)

   387

          ERROR;

   388

      }

   389

      else

   390

        return NULL;

   391

   392

      current_element_name = identifier;

   393

      return current_element_name;

   394

    }

   395

   396

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

   397

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

   398

     */

   399

    symbol_c *default_value(void) {

   400

      return current_element_default_value;

   401

    }

   402

   403

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

   404

    symbol_c *element_type(void) {

   405

      return current_element_type;

   406

    }

   407

   408

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

   409

/* B 1.3.3 - Derived data types */

   410

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

   411

   412

    /* helper symbol for structure_declaration */

   413

    /* structure_element_declaration_list structure_element_declaration ';' */

   414

    void *visit(structure_element_declaration_list_c *symbol) {

   415

      void *res;

   416

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

   417

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

   418

        if (res != NULL)

   419

          return res;

   420

      }

   421

      return NULL;

   422

    }

   423

   424

    /*  structure_element_name ':' *_spec_init */

   425

    void *visit(structure_element_declaration_c *symbol) {

   426

      element_count++;

   427

      if (next_element == element_count) {

   428

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

   429

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

   430

        if (current_element_type == NULL) ERROR;

   431

        return symbol->structure_element_name;

   432

      }

   433

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

   434

      return NULL;

   435

    }

   436

   437

};

   438

   439

/*

   440

 * Structure init element iterator.

   441

 * It will search through the elements of a structure initialization

   442

 */

   443

class structure_init_element_iterator_c : public null_visitor_c {

   444

  private:

   445

    /* a pointer to the structure initialization

   446

     * currently being analysed.

   447

     */

   448

    symbol_c *structure_initialization;

   449

    identifier_c *search_element_name;

   450

   451

  public:

   452

    /* initialise the iterator object.

   453

     * We must be given a reference to the structure initialization

   454

     * that will be analysed...

   455

     */

   456

    structure_init_element_iterator_c(symbol_c *structure_initialization) {

   457

      this->structure_initialization = structure_initialization;

   458

      search_element_name = NULL;

   459

    }

   460

   461

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

   462

    symbol_c *search(symbol_c *element_name) {

   463

      if (NULL == element_name) ERROR;

   464

      search_element_name = dynamic_cast<identifier_c *>(element_name);

   465

      if (NULL == search_element_name) ERROR;

   466

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

   467

      return (symbol_c *)res;

   468

    }

   469

   470

    /* helper symbol for structure_initialization */

   471

    /* structure_element_initialization_list ',' structure_element_initialization */

   472

    void *visit(structure_element_initialization_list_c *symbol) {

   473

      void *res;

   474

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

   475

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

   476

        if (res != NULL)

   477

          return res;

   478

      }

   479

      return NULL;

   480

    }

   481

   482

    /*  structure_element_name ASSIGN value */

   483

    void *visit(structure_element_initialization_c *symbol) {

   484

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

   485

   486

      if (element_name == NULL) ERROR;

   487

   488

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

   489

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

   490

        return (void *)symbol->value;