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

   109

      s4o.print(" temp = ");

   110

   111

      init_array_values(array_initialization);

   112

   113

      s4o.print(";\n");

   114

      var1_list->accept(*this);

   115

      s4o.indent_left();

   116

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

   117

    }

   118

   119

    void init_array_values(symbol_c *array_initialization) {

   120

      s4o.print("{{");

   121

   122

      current_mode = initializationvalue_am;

   123

      array_initialization->accept(*this);

   124

   125

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

   126

        array_default_initialization->accept(*this);

   127

      if (defined_values_count < array_size) {

   128

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

   129

          if (defined_values_count > 0)

   130

            s4o.print(",");

   131

          array_default_value->accept(*this);

   132

          defined_values_count++;

   133

        }

   134

      }

   135

   136

      s4o.print("}}");

   137

    }

   138

   139

    void *visit(identifier_c *type_name) {

   140

      symbol_c *type_decl;

   141

      switch (current_mode) {

   142

        case arraysize_am:

   143

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

   144

          type_decl = type_symtable.find_value(type_name);

   145

          if (type_decl == type_symtable.end_value())

   146

            /* Type declaration not found!! */

   147

            ERROR;

   148

          type_decl->accept(*this);

   149

          break;

   150

        default:

   151

          print_token(type_name);

   152

          break;

   153

      }

   154

      return NULL;

   155

    }

   156

   157

    void *visit(var1_list_c *symbol) {

   158

      int i, j;

   159

   160

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

   161

        s4o.print(s4o.indent_spaces);

   162

        s4o.print(SET_VAR);

   163

        s4o.print("(");

   164

        print_variable_prefix();

   165

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

   166

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

   167

      }

   168

      return NULL;

   169

    }

   170

   171

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

   172

/* B 1.3.3 - Derived data types */

   173

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

   174

   175

    /* array_specification [ASSIGN array_initialization] */

   176

    /* array_initialization may be NULL ! */

   177

    void *visit(array_spec_init_c *symbol) {

   178

      switch (current_mode) {

   179

        case arraysize_am:

   180

          array_default_initialization = symbol->array_initialization;

   181

          break;

   182

        default:

   183

          break;

   184

      }

   185

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

   186

      return NULL;

   187

    }

   188

   189

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

   190

    void *visit(array_specification_c *symbol) {

   191

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

   192

      switch (current_mode) {

   193

        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;

   198

        default:

   199

          break;

   200

      } 

   201

      return NULL;

   202

    }

   203

   204

    /*  signed_integer DOTDOT signed_integer */

   205

    //SYM_REF2(subrange_c, lower_limit, upper_limit)

   206

    void *visit(subrange_c *symbol) {

   207

      switch (current_mode) {

   208

        case arraysize_am:

   209

          array_size *= extract_integer(symbol->upper_limit) - extract_integer(symbol->lower_limit) + 1;

   210

          break;

   211

        default:

   212

          break;

   213

      }

   214

      return NULL;

   215

    }

   216

   217

    /* helper symbol for array_initialization */

   218

    /* array_initial_elements_list ',' array_initial_elements */

   219

    void *visit(array_initial_elements_list_c *symbol) {

   220

      switch (current_mode) {

   221

        case initializationvalue_am:

   222

          current_initialization_count = 0;

   223

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

   224

            if (current_initialization_count >= defined_values_count) {

   225

              if (defined_values_count >= array_size)

   226

                ERROR;

   227

              if (defined_values_count > 0)

   228

                s4o.print(",");

   229

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

   230

              defined_values_count++;

   231

            }

   232

            else {

   233

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

   234

   235

              if (array_initial_element != NULL) {

   236

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

   237

              }

   238

            }

   239

            current_initialization_count++;

   240

          }

   241

          break;

   242

        default:

   243

          break;

   244

      }

   245

      return NULL;

   246

    }

   247

   248

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

   249

    /* array_initial_element may be NULL ! */

   250

    void *visit(array_initial_elements_c *symbol) {

   251

      int initial_element_number;

   252

   253

      switch (current_mode) {

   254

        case initializationvalue_am:

   255

          initial_element_number = extract_integer(symbol->integer);

   256

          if (current_initialization_count < defined_values_count) {

   257

            int temp_element_number = 0;

   258

            int diff = defined_values_count - current_initialization_count;

   259

            if (diff <= initial_element_number)

   260

              temp_element_number = initial_element_number - diff;

   261

            current_initialization_count += initial_element_number - 1;

   262

            initial_element_number = temp_element_number;

   263

            if (initial_element_number > 0) {

   264

              defined_values_count++;

   265

              s4o.print(",");

   266

            }

   267

          }

   268

          else

   269

            current_initialization_count += initial_element_number - 1;

   270

          if (defined_values_count + initial_element_number > array_size)

   271

            ERROR;

   272

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

   273

            if (i > 0)

   274

              s4o.print(",");

   275

            if (symbol->array_initial_element != NULL) {

   276

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

   277

            }

   278

            else {

   279

              array_default_value->accept(*this);

   280

            }

   281

          }

   282

          if (initial_element_number > 1)

   283

            defined_values_count += initial_element_number - 1;

   284

          break;

   285

        default:

   286

          break;

   287

      }

   288

      return NULL;

   289

    }

   290

   291

    void *visit(structure_element_initialization_list_c *symbol);

   292

};

   293

   294

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

   295

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

   296

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

   297

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

   298

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

   299

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

   300

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

   301

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

   302

   303

/* given a structure_element_declaration_list_c, iterate 

   304

 * through each element, returning the name

   305

 * of each element...structure_element_iterator_c

   306

 */

   307

class structure_element_iterator_c : public null_visitor_c {

   308

   309

  private:

   310

    /* a pointer to the structure_element_declaration_list_c

   311

     * currently being analysed.

   312

     */

   313

    symbol_c *type_decl;

   314

    int next_element, element_count;

   315

    identifier_c *current_element_name;

   316

    symbol_c *current_element_type;

   317

    symbol_c *current_element_default_value;

   318

   319

   320

  public:

   321

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

   322

    void reset(void) {

   323

      next_element = element_count = 0;

   324

      current_element_name = NULL;

   325

      current_element_type = current_element_default_value = NULL;

   326

    }

   327

   328

    /* initialise the iterator object.

   329

     * We must be given a reference to the function declaration

   330

     * that will be analysed...

   331

     */

   332

    structure_element_iterator_c(symbol_c *type_decl) {

   333

      this->type_decl = type_decl;

   334

      reset();

   335

    }

   336

   337

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

   338

     * the object references on 

   339

     * element _before_ the first, so

   340

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

   341

     * reference the first element...

   342

     *

   343

     * Returns the element's name!

   344

     */

   345

    identifier_c *next(void) {

   346

      void *res;

   347

      identifier_c *identifier;

   348

      element_count = 0;

   349

      next_element++;

   350

      res = type_decl->accept(*this);

   351

      if (res != NULL) {

   352

        symbol_c *sym = (symbol_c *)res;

   353

        identifier = dynamic_cast<identifier_c *>(sym);

   354

        if (identifier == NULL)

   355

          ERROR;

   356

      }

   357

      else

   358

        return NULL;

   359

   360

      current_element_name = identifier;

   361

      return current_element_name;

   362

    }

   363

   364

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

   365

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

   366

     */

   367

    symbol_c *default_value(void) {

   368

      return current_element_default_value;

   369

    }

   370

   371

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

   372

    symbol_c *element_type(void) {

   373

      return current_element_type;

   374

    }

   375

   376

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

   377

/* B 1.3.3 - Derived data types */

   378

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

   379

   380

    /* helper symbol for structure_declaration */

   381

    /* structure_element_declaration_list structure_element_declaration ';' */

   382

    void *visit(structure_element_declaration_list_c *symbol) {

   383

      void *res;

   384

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

   385

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

   386

        if (res != NULL)

   387

          return res;

   388

      }

   389

      return NULL;

   390

    }

   391

   392

    /*  structure_element_name ':' *_spec_init */

   393

    void *visit(structure_element_declaration_c *symbol) {

   394

      element_count++;

   395

      if (next_element == element_count) {

   396

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

   397

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

   398

        return symbol->structure_element_name;

   399

      }

   400

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

   401

      return NULL;

   402

    }

   403

   404

};

   405

   406

/*

   407

 * Structure init element iterator.

   408

 * It will search through the elements of a structure initialization

   409

 */

   410

class structure_init_element_iterator_c : public null_visitor_c {

   411

  private:

   412

    /* a pointer to the structure initialization

   413

     * currently being analysed.

   414

     */

   415

    symbol_c *structure_initialization;

   416

    identifier_c *search_element_name;

   417

   418

  public:

   419

    /* initialise the iterator object.

   420

     * We must be given a reference to the structure initialization

   421

     * that will be analysed...

   422

     */

   423

    structure_init_element_iterator_c(symbol_c *structure_initialization) {

   424

      this->structure_initialization = structure_initialization;

   425

      search_element_name = NULL;

   426

    }

   427

   428

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

   429

    symbol_c *search(symbol_c *element_name) {

   430

      if (NULL == element_name) ERROR;

   431

      search_element_name = dynamic_cast<identifier_c *>(element_name);

   432

      if (NULL == search_element_name) ERROR;

   433

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

   434

      return (symbol_c *)res;

   435

    }

   436

   437

    /* helper symbol for structure_initialization */

   438

    /* structure_element_initialization_list ',' structure_element_initialization */

   439

    void *visit(structure_element_initialization_list_c *symbol) {

   440

      void *res;

   441

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

   442

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

   443

        if (res != NULL)

   444

          return res;

   445

      }

   446

      return NULL;

   447

    }

   448

   449

    /*  structure_element_name ASSIGN value */

   450

    void *visit(structure_element_initialization_c *symbol) {

   451

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

   452

   453

      if (element_name == NULL) ERROR;

   454

   455

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

   456

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

   457

        return (void *)symbol->value;

   458

      return NULL;

   459

    }

   460

};

   461

   462

class generate_c_structure_initialization_c: public generate_c_typedecl_c {

   463

   464

  public:

   465

    typedef enum {

   466

      none_sm,

   467

      initdefault_sm,

   468

      typedecl_sm,

   469

      initializationvalue_sm

   470

    } structureinitialization_mode_t;

   471

   472

    structureinitialization_mode_t current_mode;

   473

   474

  private:

   475

    symbol_c* structure_type_decl;

   476

    symbol_c* current_element_type;

   477

   478

  public:

   479

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

   480

    ~generate_c_structure_initialization_c(void) {}

   481

   482

    void init_structure_default(symbol_c *structure_type_name) {

   483

      structure_type_decl = NULL;

   484

      current_element_type = NULL;

   485

   486

      current_mode = initdefault_sm;

   487

      structure_type_name->accept(*this);

   488

    }

   489

   490

    void init_structure(symbol_c *var1_list, symbol_c *structure_type_name, symbol_c *structure_initialization) {

   491

      int i;

   492