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("_");

   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_number;

   269

   270

      switch (current_mode) {

   271

        case initializationvalue_am:

   272

          initial_element_number = extract_int64_value(symbol->integer);

   273

          if (current_initialization_count < defined_values_count) {

   274

            unsigned long long int temp_element_number = 0;

   275

            unsigned long long int diff = defined_values_count - current_initialization_count;

   276

            if (diff <= initial_element_number)

   277

              temp_element_number = initial_element_number - diff;

   278

            current_initialization_count += initial_element_number - 1;

   279

            initial_element_number = temp_element_number;

   280

            if (initial_element_number > 0) {

   281

              defined_values_count++;

   282

              s4o.print(",");

   283

            }

   284

          }

   285

          else

   286

            current_initialization_count += initial_element_number - 1;

   287

          if (defined_values_count + initial_element_number > array_size)

   288

            ERROR;

   289

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

   290

            if (i > 0)

   291

              s4o.print(",");

   292

            if (symbol->array_initial_element != NULL) {

   293

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

   294

            }

   295

            else {

   296

              array_default_value->accept(*this);

   297

            }

   298

          }

   299

          if (initial_element_number > 1)

   300

            defined_values_count += initial_element_number - 1;

   301

          break;

   302

        default:

   303

          break;

   304

      }

   305

      return NULL;

   306

    }

   307

   308

    void *visit(structure_element_initialization_list_c *symbol);

   309

};

   310

   311

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

   312

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

   313

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

   314

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

   315

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

   316

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

   317

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

   318

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

   319

   320

/* given a structure_element_declaration_list_c, iterate 

   321

 * through each element, returning the name

   322

 * of each element...structure_element_iterator_c

   323

 */

   324

class structure_element_iterator_c : public null_visitor_c {

   325

   326

  private:

   327

    /* a pointer to the structure_element_declaration_list_c

   328

     * currently being analysed.

   329

     */

   330

    symbol_c *type_decl;

   331

    int next_element, element_count;

   332

    identifier_c *current_element_name;

   333

    symbol_c *current_element_type;

   334

    symbol_c *current_element_default_value;

   335

   336

   337

  public:

   338

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

   339

    void reset(void) {

   340

      next_element = element_count = 0;

   341

      current_element_name = NULL;

   342

      current_element_type = current_element_default_value = NULL;

   343

    }

   344

   345

    /* initialise the iterator object.

   346

     * We must be given a reference to the function declaration

   347

     * that will be analysed...

   348

     */

   349

    structure_element_iterator_c(symbol_c *type_decl) {

   350

      this->type_decl = type_decl;

   351

      reset();

   352

    }

   353

   354

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

   355

     * the object references on 

   356

     * element _before_ the first, so

   357

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

   358

     * reference the first element...

   359

     *

   360

     * Returns the element's name!

   361

     */

   362

    identifier_c *next(void) {

   363

      void *res;

   364

      identifier_c *identifier;

   365

      element_count = 0;

   366

      next_element++;

   367

      res = type_decl->accept(*this);

   368

      if (res != NULL) {

   369

        symbol_c *sym = (symbol_c *)res;

   370

        identifier = dynamic_cast<identifier_c *>(sym);

   371

        if (identifier == NULL)

   372

          ERROR;

   373

      }

   374

      else

   375

        return NULL;

   376

   377

      current_element_name = identifier;

   378

      return current_element_name;

   379

    }

   380

   381

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

   382

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

   383

     */

   384

    symbol_c *default_value(void) {

   385

      return current_element_default_value;

   386

    }

   387

   388

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

   389

    symbol_c *element_type(void) {

   390

      return current_element_type;

   391

    }

   392

   393

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

   394

/* B 1.3.3 - Derived data types */

   395

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

   396

   397

    /* helper symbol for structure_declaration */

   398

    /* structure_element_declaration_list structure_element_declaration ';' */

   399

    void *visit(structure_element_declaration_list_c *symbol) {

   400

      void *res;

   401

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

   402

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

   403

        if (res != NULL)

   404

          return res;

   405

      }

   406

      return NULL;

   407

    }

   408

   409

    /*  structure_element_name ':' *_spec_init */

   410

    void *visit(structure_element_declaration_c *symbol) {

   411

      element_count++;

   412

      if (next_element == element_count) {

   413

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

   414

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

   415

        return symbol->structure_element_name;

   416

      }

   417

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

   418

      return NULL;

   419

    }

   420

   421

};

   422

   423

/*

   424

 * Structure init element iterator.

   425

 * It will search through the elements of a structure initialization

   426

 */

   427

class structure_init_element_iterator_c : public null_visitor_c {

   428

  private:

   429

    /* a pointer to the structure initialization

   430

     * currently being analysed.

   431

     */

   432

    symbol_c *structure_initialization;

   433

    identifier_c *search_element_name;

   434

   435

  public:

   436

    /* initialise the iterator object.

   437

     * We must be given a reference to the structure initialization

   438

     * that will be analysed...

   439

     */

   440

    structure_init_element_iterator_c(symbol_c *structure_initialization) {

   441

      this->structure_initialization = structure_initialization;

   442

      search_element_name = NULL;

   443

    }

   444

   445

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

   446

    symbol_c *search(symbol_c *element_name) {

   447

      if (NULL == element_name) ERROR;

   448

      search_element_name = dynamic_cast<identifier_c *>(element_name);

   449

      if (NULL == search_element_name) ERROR;

   450

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

   451

      return (symbol_c *)res;

   452

    }

   453

   454

    /* helper symbol for structure_initialization */

   455

    /* structure_element_initialization_list ',' structure_element_initialization */

   456

    void *visit(structure_element_initialization_list_c *symbol) {

   457

      void *res;

   458

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

   459

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

   460

        if (res != NULL)

   461

          return res;

   462

      }

   463

      return NULL;

   464

    }

   465

   466

    /*  structure_element_name ASSIGN value */

   467

    void *visit(structure_element_initialization_c *symbol) {

   468

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

   469

   470

      if (element_name == NULL) ERROR;

   471

   472

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

   473

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

   474

        return (void *)symbol->value;

   475

      return NULL;

   476

    }

   477

};

   478

   479

class generate_c_structure_initialization_c: public generate_c_typedecl_c {

   480

   481

  public:

   482

    typedef enum {

   483

      none_sm,

   484

      initdefault_sm,

   485

      typedecl_sm,

   486

      initializationvalue_sm

   487

    } structureinitialization_mode_t;

   488

   489

    structureinitialization_mode_t current_mode;

   490

   491

  private: