1

/*

     2

 * (c) 2003 Mario de Sousa

     3

 *

     4

 * Offered to the public under the terms of the GNU General Public License

     5

 * as published by the Free Software Foundation; either version 2 of the

     6

 * License, or (at your option) any later version.

     7

 *

     8

 * This program is distributed in the hope that it will be useful, but

     9

 * WITHOUT ANY WARRANTY; without even the implied warranty of

    10

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General

    11

 * Public License for more details.

    12

 *

    13

 * This code is made available on the understanding that it will not be

    14

 * used in safety-critical situations without a full and competent review.

    15

 */

    16

    17

/*

    18

 * An IEC 61131-3 IL and ST compiler.

    19

 *

    20

 * Based on the

    21

 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    22

 *

    23

 */

    24

    25

    26

/*

    27

 * Conversion of variable declaration constructs.

    28

 *

    29

 * This is part of the 4th stage that generates

    30

 * a c++ source program equivalent to the IL and ST

    31

 * code.

    32

 */

    33

    34

    35

    36

    37

//#include <stdio.h>  /* required for NULL */

    38

//#include <string>

    39

//#include <iostream>

    40

    41

//#include "../../util/symtable.hh"

    42

    43

class initialization_analyzer_c: public null_visitor_c {

    44

  public:

    45

	typedef enum {

    46

	  simple_it,

    47

	  array_it,

    48

	  struct_it

    49

	} initialization_type_t;

    50

    51

  private:

    52

    53

	initialization_type_t current_type;

    54

    55

  public:

    56

	initialization_analyzer_c(symbol_c* symbol) {

    57

	  current_type = simple_it;

    58

      symbol->accept(*this);

    59

	}

    60

	~initialization_analyzer_c(void) {}

    61

    62

	initialization_type_t get_initialization_type(void) {

    63

	  return current_type;

    64

	}

    65

    66

	void *visit(array_initial_elements_list_c *symbol) {

    67

      current_type = array_it;

    68

      return NULL;

    69

	}

    70

    71

    void *visit(structure_element_initialization_list_c *symbol) {

    72

      current_type = struct_it;

    73

      return NULL;

    74

    }

    75

};

    76

    77

class generate_c_array_initialization_c: public generate_c_typedecl_c {

    78

    79

  public:

    80

    typedef enum {

    81

      none_am,

    82

      dimensioncount_am,

    83

      initializationvalue_am,

    84

      arrayassignment_am,

    85

      varlistparse_am

    86

    } arrayinitialization_mode_t;

    87

    88

    arrayinitialization_mode_t current_mode;

    89

    90

    symbol_c* array_base_type;

    91

    symbol_c* array_default_value;

    92

    symbol_c* array_default_initialization;

    93

    94

  private:

    95

    int dimension_number;

    96

    int current_dimension;

    97

    int array_size;

    98

    int defined_values_count;

    99

    int current_initialization_count;

   100

   101

  public:

   102

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

   103

    ~generate_c_array_initialization_c(void) {}

   104

   105

    void init_array_dimensions(symbol_c *array_specification) {

   106

      dimension_number = 0;

   107

      current_dimension = 0;

   108

      array_size = 1;

   109

      defined_values_count = 0;

   110

      current_initialization_count = 0;

   111

      array_base_type = array_default_value = array_default_initialization = NULL;

   112

   113

      current_mode = dimensioncount_am;

   114

      array_specification->accept(*this);

   115

    }

   116

   117

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

   118

      int i;

   119

   120

      init_array_dimensions(array_specification);

   121

   122

      current_mode = initializationvalue_am;

   123

      s4o.print("\n");

   124

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

   125

      s4o.indent_right();

   126

      s4o.print(s4o.indent_spaces + "int index[");

   127

      print_integer(dimension_number);

   128

      s4o.print("];\n");

   129

      s4o.print(s4o.indent_spaces);

   130

      s4o.print("static const ");

   131

      array_specification->accept(*this);

   132

      s4o.print(" temp = ");

   133

      init_array_values(array_initialization);

   134

      s4o.print(";\n");

   135

   136

      current_mode = arrayassignment_am;

   137

      array_specification->accept(*this);

   138

   139

      current_mode = varlistparse_am;

   140

      var1_list->accept(*this);

   141

   142

      current_mode = arrayassignment_am;

   143

      for (i = 0; i < dimension_number; i++) {

   144

        s4o.indent_left();

   145

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

   146

      }

   147

      s4o.indent_left();

   148

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

   149

    }

   150

   151

    void init_array_values(symbol_c *array_initialization) {

   152

      s4o.print("{");

   153

      array_initialization->accept(*this);

   154

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

   155

        array_default_initialization->accept(*this);

   156

      if (defined_values_count < array_size) {

   157

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

   158

          if (defined_values_count > 0)

   159

            s4o.print(",");

   160

          array_default_value->accept(*this);

   161

          defined_values_count++;

   162

        }

   163

      }

   164

      s4o.print("}");

   165

    }

   166

   167

    void *visit(identifier_c *type_name) {

   168

      symbol_c *type_decl;

   169

      switch (current_mode) {

   170

        case dimensioncount_am:

   171

        case arrayassignment_am:

   172

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

   173

          type_decl = type_symtable.find_value(type_name);

   174

          if (type_decl == type_symtable.end_value())

   175

            /* Type declaration not found!! */

   176

            ERROR;

   177

          type_decl->accept(*this);

   178

          break;

   179

        default:

   180

          print_token(type_name);

   181

          break;

   182

      }

   183

      return NULL;

   184

    }

   185

   186

    void *visit(var1_list_c *symbol) {

   187

      int i, j;

   188

   189

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

   190

        s4o.print(s4o.indent_spaces);

   191

        s4o.print(SET_VAR);

   192

        s4o.print("(");

   193

        print_variable_prefix();

   194

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

   195

        s4o.print(",temp");

   196

        for (j = 0; j < dimension_number; j++) {

   197

          s4o.print("[index[");

   198

          print_integer(j);

   199

          s4o.print("]]");

   200

        }

   201

        s4o.print(",");

   202

        for (j = 0; j < dimension_number; j++) {

   203

          s4o.print("[index[");

   204

          print_integer(j);

   205

          s4o.print("]]");

   206

        }

   207

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

   208

      }

   209

      return NULL;

   210

    }

   211

   212

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

   213

/* B 1.3.3 - Derived data types */

   214

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

   215

   216

    /* array_specification [ASSIGN array_initialization] */

   217

    /* array_initialization may be NULL ! */

   218

    void *visit(array_spec_init_c *symbol) {

   219

      switch (current_mode) {

   220

        case dimensioncount_am:

   221

          array_default_initialization = symbol->array_initialization;

   222

          break;

   223

        default:

   224

          break;

   225

      }

   226

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

   227

      return NULL;

   228

    }

   229

   230

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

   231

    void *visit(array_specification_c *symbol) {

   232

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

   233

      switch (current_mode) {

   234

        case dimensioncount_am:

   235

          array_base_type = symbol->non_generic_type_name;

   236

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

   237

          if (array_default_value == NULL) ERROR;

   238

          break;

   239

        default:

   240

          break;

   241

      } 

   242

      return NULL;

   243

    }

   244

   245

    /*  signed_integer DOTDOT signed_integer */

   246

    //SYM_REF2(subrange_c, lower_limit, upper_limit)

   247

    void *visit(subrange_c *symbol) {

   248

      switch (current_mode) {

   249

        case dimensioncount_am:

   250

          dimension_number++;

   251

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

   252

          break;

   253

        case arrayassignment_am:

   254

          s4o.print(s4o.indent_spaces + "for (index[");

   255

          print_integer(current_dimension);

   256

          s4o.print("] = 0; index[");

   257

          print_integer(current_dimension);

   258

          s4o.print("] <= ");

   259

          print_integer(extract_integer(symbol->upper_limit) - extract_integer(symbol->lower_limit));

   260

          s4o.print("; index[");

   261

          print_integer(current_dimension);

   262

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

   263

          s4o.indent_right();

   264

          current_dimension++;

   265

          break;

   266

        default:

   267

          break;

   268

      }

   269

      return NULL;

   270

    }

   271

   272

    /* helper symbol for array_initialization */

   273

    /* array_initial_elements_list ',' array_initial_elements */

   274

    void *visit(array_initial_elements_list_c *symbol) {

   275

      switch (current_mode) {

   276

        case initializationvalue_am:

   277

          current_initialization_count = 0;

   278

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

   279

            if (current_initialization_count >= defined_values_count) {

   280

              if (defined_values_count >= array_size)

   281

                ERROR;

   282

              if (defined_values_count > 0)

   283

                s4o.print(",");

   284

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

   285

              defined_values_count++;

   286

            }

   287

            else {

   288

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

   289

   290

              if (array_initial_element != NULL) {

   291

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

   292

              }

   293

            }

   294

            current_initialization_count++;

   295

          }

   296

          break;

   297

        default:

   298

          break;

   299

      }

   300

      return NULL;

   301

    }

   302

   303

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

   304

    /* array_initial_element may be NULL ! */

   305

    void *visit(array_initial_elements_c *symbol) {

   306

      int initial_element_number;

   307

   308

      switch (current_mode) {

   309

        case initializationvalue_am:

   310

          initial_element_number = extract_integer(symbol->integer);

   311

          if (current_initialization_count < defined_values_count) {

   312

            int temp_element_number = 0;

   313

            int diff = defined_values_count - current_initialization_count;

   314

            if (diff <= initial_element_number)

   315

              temp_element_number = initial_element_number - diff;

   316

            current_initialization_count += initial_element_number - 1;

   317

            initial_element_number = temp_element_number;

   318

            if (initial_element_number > 0) {

   319

              defined_values_count++;

   320

              s4o.print(",");

   321

            }

   322

          }

   323

          else

   324

            current_initialization_count += initial_element_number - 1;

   325

          if (defined_values_count + initial_element_number > array_size)

   326

            ERROR;

   327

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

   328

            if (i > 0)

   329

              s4o.print(",");

   330

            if (symbol->array_initial_element != NULL) {

   331

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

   332

            }

   333

            else {

   334

              array_default_value->accept(*this);

   335

            }

   336

          }

   337

          if (initial_element_number > 1)

   338

            defined_values_count += initial_element_number - 1;

   339

          break;

   340

        default:

   341

          break;

   342

      }

   343

      return NULL;

   344

    }

   345

   346

    void *visit(structure_element_initialization_list_c *symbol);

   347

};

   348

   349

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

   350

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

   351

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

   352

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

   353

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

   354

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

   355

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

   356

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

   357

   358

/* given a structure_element_declaration_list_c, iterate 

   359

 * through each element, returning the name

   360

 * of each element...structure_element_iterator_c

   361

 */

   362

class structure_element_iterator_c : public null_visitor_c {

   363

   364

  private:

   365

    /* a pointer to the structure_element_declaration_list_c

   366

     * currently being analysed.

   367

     */

   368

    symbol_c *type_decl;

   369

    int next_element, element_count;

   370

    identifier_c *current_element_name;

   371

    symbol_c *current_element_type;

   372

    symbol_c *current_element_default_value;

   373

   374

   375

  public:

   376

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

   377

    void reset(void) {

   378

      next_element = element_count = 0;

   379

      current_element_name = NULL;

   380

      current_element_type = current_element_default_value = NULL;

   381

    }

   382

   383

    /* initialise the iterator object.

   384

     * We must be given a reference to the function declaration

   385

     * that will be analysed...

   386

     */

   387

    structure_element_iterator_c(symbol_c *type_decl) {

   388

      this->type_decl = type_decl;

   389

      reset();

   390

    }

   391

   392

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

   393

     * the object references on 

   394

     * element _before_ the first, so

   395

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

   396

     * reference the first element...

   397

     *

   398

     * Returns the element's name!

   399

     */

   400

    identifier_c *next(void) {

   401

      void *res;

   402

      identifier_c *identifier;

   403

      element_count = 0;

   404

      next_element++;

   405

      res = type_decl->accept(*this);

   406

      if (res != NULL) {

   407

        symbol_c *sym = (symbol_c *)res;

   408

        identifier = dynamic_cast<identifier_c *>(sym);

   409

        if (identifier == NULL)

   410

          ERROR;

   411

      }

   412

      else

   413

        return NULL;

   414

   415

      current_element_name = identifier;

   416

      return current_element_name;

   417

    }

   418

   419

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

   420

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

   421

     */

   422

    symbol_c *default_value(void) {

   423

      return current_element_default_value;

   424

    }

   425

   426

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

   427

    symbol_c *element_type(void) {

   428

      return current_element_type;

   429

    }

   430

   431

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

   432

/* B 1.3.3 - Derived data types */

   433

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

   434

   435

    /* helper symbol for structure_declaration */

   436

    /* structure_element_declaration_list structure_element_declaration ';' */

   437

    void *visit(structure_element_declaration_list_c *symbol) {

   438

      void *res;

   439

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

   440

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

   441

        if (res != NULL)

   442

          return res;

   443

      }

   444

      return NULL;

   445

    }

   446

   447

    /*  structure_element_name ':' *_spec_init */

   448

    void *visit(structure_element_declaration_c *symbol) {

   449

      element_count++;

   450

      if (next_element == element_count) {

   451

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

   452

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

   453

        return symbol->structure_element_name;

   454

      }

   455

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

   456

      return NULL;

   457

    }

   458

   459

};

   460

   461

/*

   462

 * Structure init element iterator.

   463

 * It will search through the elements of a structure initialization

   464

 */

   465

class structure_init_element_iterator_c : public null_visitor_c {

   466

  private:

   467

    /* a pointer to the structure initialization

   468

     * currently being analysed.

   469

     */

   470

    symbol_c *structure_initialization;

   471

    identifier_c *search_element_name;

   472

   473

  public:

   474

    /* initialise the iterator object.

   475

     * We must be given a reference to the structure initialization

   476

     * that will be analysed...

   477

     */

   478

    structure_init_element_iterator_c(symbol_c *structure_initialization) {

   479

      this->structure_initialization = structure_initialization;

   480

      search_element_name = NULL;

   481

    }

   482

   483

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

   484

    symbol_c *search(symbol_c *element_name) {

   485

      if (NULL == element_name) ERROR;

   486

      search_element_name = dynamic_cast<identifier_c *>(element_name);

   487

      if (NULL == search_element_name) ERROR;

   488

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

   489

      return (symbol_c *)res;

   490

    }

   491

   492

    /* helper symbol for structure_initialization */

   493

    /* structure_element_initialization_list ',' structure_element_initialization */

   494

    void *visit(structure_element_initialization_list_c *symbol) {

   495

      void *res;

   496

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