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

class initialization_analyzer_c: public null_visitor_c {

    26

  public:

    27

	typedef enum {

    28

	  simple_it,

    29

	  array_it,

    30

	  struct_it

    31

	} initialization_type_t;

    32

    33

  private:

    34

    35

	initialization_type_t current_type;

    36

    37

  public:

    38

	initialization_analyzer_c(symbol_c* symbol) {

    39

	  current_type = simple_it;

    40

      symbol->accept(*this);

    41

	}

    42

	~initialization_analyzer_c(void) {}

    43

    44

	initialization_type_t get_initialization_type(void) {

    45

	  return current_type;

    46

	}

    47

    48

	void *visit(array_initial_elements_list_c *symbol) {

    49

      current_type = array_it;

    50

      return NULL;

    51

	}

    52

    53

    void *visit(structure_element_initialization_list_c *symbol) {

    54

      current_type = struct_it;

    55

      return NULL;

    56

    }

    57

};

    58

    59

class generate_c_array_initialization_c: public generate_c_typedecl_c {

    60

    61

  public:

    62

    typedef enum {

    63

      none_am,

    64

      arraysize_am,

    65

      typedecl_am,

    66

      initializationvalue_am

    67

    } arrayinitialization_mode_t;

    68

    69

    arrayinitialization_mode_t current_mode;

    70

    71

    symbol_c* array_base_type;

    72

    symbol_c* array_default_value;

    73

    symbol_c* array_default_initialization;

    74

    75

  private:

    76

    int current_dimension;

    77

    int array_size;

    78

    int defined_values_count;

    79

    int current_initialization_count;

    80

    81

  public:

    82

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

    83

    ~generate_c_array_initialization_c(void) {}

    84

    85

    void init_array_size(symbol_c *array_specification) {

    86

      array_size = 1;

    87

      defined_values_count = 0;

    88

      current_initialization_count = 0;

    89

      array_base_type = array_default_value = array_default_initialization = NULL;

    90

    91

      current_mode = arraysize_am;

    92

      array_specification->accept(*this);

    93

    }

    94

    95

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

    96

      int i;

    97

    98

      init_array_size(array_specification);

    99

   100

      s4o.print("\n");

   101

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

   102

      s4o.indent_right();

   103

      s4o.print(s4o.indent_spaces);

   104

      s4o.print("static const ");

   105

   106

      current_mode = typedecl_am;

   107

      array_specification->accept(*this);

   108

      s4o.print(" temp = ");

   109

   110

      init_array_values(array_initialization);

   111

   112

      s4o.print(";\n");

   113

      var1_list->accept(*this);

   114

      s4o.indent_left();

   115

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

   116

    }

   117

   118

    void init_array_values(symbol_c *array_initialization) {

   119

      s4o.print("{{");

   120

   121

      current_mode = initializationvalue_am;

   122

      array_initialization->accept(*this);

   123

   124

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

   125

        array_default_initialization->accept(*this);

   126

      if (defined_values_count < array_size) {

   127

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

   128

          if (defined_values_count > 0)

   129

            s4o.print(",");

   130

          array_default_value->accept(*this);

   131

          defined_values_count++;

   132

        }

   133

      }

   134

   135

      s4o.print("}}");

   136

    }

   137

   138

    void *visit(identifier_c *type_name) {

   139

      symbol_c *type_decl;

   140

      switch (current_mode) {

   141

        case arraysize_am:

   142

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

   143

          type_decl = type_symtable.find_value(type_name);

   144

          if (type_decl == type_symtable.end_value())

   145

            /* Type declaration not found!! */

   146

            ERROR;

   147

          type_decl->accept(*this);

   148

          break;

   149

        default:

   150

          print_token(type_name);

   151

          break;

   152

      }

   153

      return NULL;

   154

    }

   155

   156

    void *visit(var1_list_c *symbol) {

   157

      int i, j;

   158

   159

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

   160

        s4o.print(s4o.indent_spaces);

   161

        s4o.print(SET_VAR);

   162

        s4o.print("(");

   163

        print_variable_prefix();

   164

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

   165

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

   166

      }

   167

      return NULL;

   168

    }

   169

   170

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

   171

/* B 1.3.3 - Derived data types */

   172

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

   173

   174

    /* array_specification [ASSIGN array_initialization] */

   175

    /* array_initialization may be NULL ! */

   176

    void *visit(array_spec_init_c *symbol) {

   177

      switch (current_mode) {

   178

        case arraysize_am:

   179

          array_default_initialization = symbol->array_initialization;

   180

          break;

   181

        default:

   182

          break;

   183

      }

   184

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

   185

      return NULL;

   186

    }

   187

   188

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

   189

    void *visit(array_specification_c *symbol) {

   191

      switch (current_mode) {

   192

        case arraysize_am:

   194

          array_base_type = symbol->non_generic_type_name;

   195

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

   196

          if (array_default_value == NULL) ERROR;

   197

          break;

   203

        default:

   205

          break;

   206

      } 

   207

      return NULL;

   208

    }

   209

   210

    /*  signed_integer DOTDOT signed_integer */

   211

    //SYM_REF2(subrange_c, lower_limit, upper_limit)

   212

    void *visit(subrange_c *symbol) {

   214

      switch (current_mode) {

   215

        case arraysize_am:

   221

          break;

   222

        default:

   223

          break;

   224

      }

   225

      return NULL;

   226

    }

   227

   228

    /* helper symbol for array_initialization */

   229

    /* array_initial_elements_list ',' array_initial_elements */

   230

    void *visit(array_initial_elements_list_c *symbol) {

   231

      switch (current_mode) {

   232

        case initializationvalue_am:

   233

          current_initialization_count = 0;

   234

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

   235

            if (current_initialization_count >= defined_values_count) {

   236

              if (defined_values_count >= array_size)

   237

                ERROR;

   238

              if (defined_values_count > 0)

   239

                s4o.print(",");

   240

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

   241

              defined_values_count++;

   242

            }

   243

            else {

   244

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

   245

   246

              if (array_initial_element != NULL) {

   247

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

   248

              }

   249

            }

   250

            current_initialization_count++;

   251

          }

   252

          break;

   253

        default:

   254

          break;

   255

      }

   256

      return NULL;

   257

    }

   258

   259

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

   260

    /* array_initial_element may be NULL ! */

   261

    void *visit(array_initial_elements_c *symbol) {

   262

      int initial_element_number;

   263

   264

      switch (current_mode) {

   265

        case initializationvalue_am:

   266

          initial_element_number = extract_integer(symbol->integer);

   267

          if (current_initialization_count < defined_values_count) {

   268

            int temp_element_number = 0;

   269

            int diff = defined_values_count - current_initialization_count;

   270

            if (diff <= initial_element_number)

   271

              temp_element_number = initial_element_number - diff;

   272

            current_initialization_count += initial_element_number - 1;

   273

            initial_element_number = temp_element_number;

   274

            if (initial_element_number > 0) {

   275

              defined_values_count++;

   276

              s4o.print(",");

   277

            }

   278

          }

   279

          else

   280

            current_initialization_count += initial_element_number - 1;

   281

          if (defined_values_count + initial_element_number > array_size)

   282

            ERROR;

   283

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

   284

            if (i > 0)

   285

              s4o.print(",");

   286

            if (symbol->array_initial_element != NULL) {

   287

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

   288

            }

   289

            else {

   290

              array_default_value->accept(*this);

   291

            }

   292

          }

   293

          if (initial_element_number > 1)

   294

            defined_values_count += initial_element_number - 1;

   295

          break;

   296

        default:

   297

          break;

   298

      }

   299

      return NULL;

   300

    }

   301

   302

    void *visit(structure_element_initialization_list_c *symbol);

   303

};

   304

   305

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

   306

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

   307

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

   308

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

   309

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

   310

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

   311

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

   312

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

   313

   314

/* given a structure_element_declaration_list_c, iterate 

   315

 * through each element, returning the name

   316

 * of each element...structure_element_iterator_c

   317

 */

   318

class structure_element_iterator_c : public null_visitor_c {

   319

   320

  private:

   321

    /* a pointer to the structure_element_declaration_list_c

   322

     * currently being analysed.

   323

     */

   324

    symbol_c *type_decl;

   325

    int next_element, element_count;

   326

    identifier_c *current_element_name;

   327

    symbol_c *current_element_type;

   328

    symbol_c *current_element_default_value;

   329

   330

   331

  public:

   332

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

   333

    void reset(void) {

   334

      next_element = element_count = 0;

   335

      current_element_name = NULL;

   336

      current_element_type = current_element_default_value = NULL;

   337

    }

   338

   339

    /* initialise the iterator object.

   340

     * We must be given a reference to the function declaration

   341

     * that will be analysed...

   342

     */

   343

    structure_element_iterator_c(symbol_c *type_decl) {

   344

      this->type_decl = type_decl;

   345

      reset();

   346

    }

   347

   348

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

   349

     * the object references on 

   350

     * element _before_ the first, so

   351

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

   352

     * reference the first element...

   353

     *

   354

     * Returns the element's name!

   355

     */

   356

    identifier_c *next(void) {

   357

      void *res;

   358

      identifier_c *identifier;

   359

      element_count = 0;

   360

      next_element++;

   361

      res = type_decl->accept(*this);

   362

      if (res != NULL) {

   363

        symbol_c *sym = (symbol_c *)res;

   364

        identifier = dynamic_cast<identifier_c *>(sym);

   365

        if (identifier == NULL)

   366

          ERROR;

   367

      }

   368

      else

   369

        return NULL;

   370

   371

      current_element_name = identifier;

   372

      return current_element_name;

   373

    }

   374

   375

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

   376

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

   377

     */

   378

    symbol_c *default_value(void) {

   379

      return current_element_default_value;

   380

    }

   381

   382

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

   383

    symbol_c *element_type(void) {

   384

      return current_element_type;

   385

    }

   386

   387

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

   388

/* B 1.3.3 - Derived data types */

   389

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

   390

   391

    /* helper symbol for structure_declaration */

   392

    /* structure_element_declaration_list structure_element_declaration ';' */

   393

    void *visit(structure_element_declaration_list_c *symbol) {

   394

      void *res;

   395

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

   396

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

   397

        if (res != NULL)

   398

          return res;

   399

      }

   400

      return NULL;

   401

    }

   402

   403

    /*  structure_element_name ':' *_spec_init */

   404

    void *visit(structure_element_declaration_c *symbol) {

   405

      element_count++;

   406

      if (next_element == element_count) {

   407

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

   408

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

   409

        return symbol->structure_element_name;

   410

      }

   411

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

   412

      return NULL;

   413

    }

   414

   415

};

   416

   417

/*

   418

 * Structure init element iterator.

   419

 * It will search through the elements of a structure initialization

   420

 */

   421

class structure_init_element_iterator_c : public null_visitor_c {

   422

  private:

   423

    /* a pointer to the structure initialization

   424

     * currently being analysed.

   425

     */

   426

    symbol_c *structure_initialization;

   427

    identifier_c *search_element_name;

   428

   429

  public:

   430

    /* initialise the iterator object.

   431

     * We must be given a reference to the structure initialization

   432

     * that will be analysed...

   433

     */

   434

    structure_init_element_iterator_c(symbol_c *structure_initialization) {

   435

      this->structure_initialization = structure_initialization;

   436

      search_element_name = NULL;

   437

    }

   438

   439

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

   440

    symbol_c *search(symbol_c *element_name) {

   441

      if (NULL == element_name) ERROR;

   442

      search_element_name = dynamic_cast<identifier_c *>(element_name);

   443

      if (NULL == search_element_name) ERROR;

   444

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

   445

      return (symbol_c *)res;

   446

    }

   447

   448

    /* helper symbol for structure_initialization */

   449

    /* structure_element_initialization_list ',' structure_element_initialization */

   450

    void *visit(structure_element_initialization_list_c *symbol) {

   451

      void *res;

   452

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

   453

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

   454

        if (res != NULL)

   455

          return res;

   456

      }

   457

      return NULL;

   458

    }

   459

   460

    /*  structure_element_name ASSIGN value */

   461

    void *visit(structure_element_initialization_c *symbol) {

   462

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

   463

   464

      if (element_name == NULL) ERROR;

   465

   466

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

   467

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

   468

        return (void *)symbol->value;

   469

      return NULL;

   470

    }

   471

};

   472

   473

class generate_c_structure_initialization_c: public generate_c_typedecl_c {

   474

   475

  public:

   476

    typedef enum {

   477

      none_sm,

   478

      initdefault_sm,

   479

      typedecl_sm,

   480

      initializationvalue_sm

   481

    } structureinitialization_mode_t;

   482

   483

    structureinitialization_mode_t current_mode;

   484

   485

  private:

   486

    symbol_c* structure_type_decl;

   487

    symbol_c* current_element_type;

   488

   489

  public:

   490

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

   491

    ~generate_c_structure_initialization_c(void) {}

   492