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

    44

    45

    46

class generate_c_array_initialization_c: public generate_c_typedecl_c {

    47

    48

  public:

    49

    typedef enum {

    50

      none_am,

    51

      dimensioncount_am,

    52

      initializationvalue_am,

    53

      arrayassignment_am,

    54

      varlistparse_am

    55

    } arrayinitialization_mode_t;

    56

    57

    arrayinitialization_mode_t current_mode;

    58

    59

    symbol_c* array_base_type;

    60

    symbol_c* array_default_value;

    61

    symbol_c* array_default_initialization;

    62

    63

  private:

    64

    int dimension_number;

    65

    int current_dimension;

    66

    int array_size;

    67

    int defined_values_count;

    68

    int current_initialization_count;

    69

    70

  public:

    71

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

    72

    ~generate_c_array_initialization_c(void) {}

    73

    74

    void init_array_dimensions(symbol_c *array_specification) {

    75

      dimension_number = 0;

    76

      current_dimension = 0;

    77

      array_size = 1;

    78

      defined_values_count = 0;

    79

      current_initialization_count = 0;

    80

      array_base_type = array_default_value = array_default_initialization = NULL;

    81

    82

      current_mode = dimensioncount_am;

    83

      array_specification->accept(*this);

    84

    }

    85

    86

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

    87

      int i;

    88

    89

      init_array_dimensions(array_specification);

    90

    91

      current_mode = initializationvalue_am;

    92

      s4o.print("\n");

    93

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

    94

      s4o.indent_right();

    95

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

    96

      print_integer(dimension_number);

    97

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

    98

      s4o.print(s4o.indent_spaces);

    99

      array_specification->accept(*this);

   100

      s4o.print(" temp = ");

   101

      init_array_values(array_initialization);

   102

      s4o.print(";\n");

   103

   104

      current_mode = arrayassignment_am;

   105

      array_specification->accept(*this);

   106

   107

      current_mode = varlistparse_am;

   108

      var1_list->accept(*this);

   109

   110

      current_mode = arrayassignment_am;

   111

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

   112

        s4o.indent_left();

   113

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

   114

      }

   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

      array_initialization->accept(*this);

   122

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

   123

        array_default_initialization->accept(*this);

   124

      if (defined_values_count < array_size) {

   125

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

   126

          if (defined_values_count > 0)

   127

            s4o.print(", ");

   128

          array_default_value->accept(*this);

   129

          defined_values_count++;

   130

        }

   131

      }

   132

      s4o.print("}");

   133

    }

   134

   135

    void *visit(identifier_c *type_name) {

   136

      symbol_c *type_decl;

   137

      switch (current_mode) {

   138

        case dimensioncount_am:

   139

        case arrayassignment_am:

   140

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

   141

          type_decl = type_symtable.find_value(type_name);

   142

          if (type_decl == type_symtable.end_value())

   143

            /* Type declaration not found!! */

   144

            ERROR;

   145

          type_decl->accept(*this);

   146

          break;

   147

        default:

   148

          print_token(type_name);

   149

          break;

   150

      }

   151

      return NULL;

   152

    }

   153

   154

    void *visit(var1_list_c *symbol) {

   155

      int i, j;

   156

   157

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

   158

        s4o.print(s4o.indent_spaces);

   159

        print_variable_prefix();

   160

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

   161

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

   162

          s4o.print("[index[");

   163

          print_integer(j);

   164

          s4o.print("]]");

   165

        }

   166

        s4o.print(" = temp");

   167

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

   168

          s4o.print("[index[");

   169

          print_integer(j);

   170

          s4o.print("]]");

   171

        }

   172

        s4o.print(";\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 dimensioncount_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

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

   198

      switch (current_mode) {

   199

        case dimensioncount_am:

   200

          array_base_type = symbol->non_generic_type_name;

   201

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

   202

          if (array_default_value == NULL) ERROR;

   203

          break;

   204

        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) {

   213

      switch (current_mode) {

   214

        case dimensioncount_am:

   215

          dimension_number++;

   216

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

   217

          break;

   218

        case arrayassignment_am:

   219

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

   220

          print_integer(current_dimension);

   221

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

   222

          print_integer(current_dimension);

   223

          s4o.print("] <= ");

   224

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

   225

          s4o.print("; index[");

   226

          print_integer(current_dimension);

   227

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

   228

          s4o.indent_right();

   229

          current_dimension++;

   230

          break;

   231

        default:

   232

          break;

   233

      }

   234

      return NULL;

   235

    }

   236

   237

    /* helper symbol for array_initialization */

   238

    /* array_initial_elements_list ',' array_initial_elements */

   239

    void *visit(array_initial_elements_list_c *symbol) {

   240

      switch (current_mode) {

   241

        case initializationvalue_am:

   242

          current_initialization_count = 0;

   243

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

   244

            if (current_initialization_count >= defined_values_count) {

   245

              if (defined_values_count >= array_size)

   246

                ERROR;

   247

              if (defined_values_count > 0)

   248

                s4o.print(", ");

   249

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

   250

              defined_values_count++;

   251

            }

   252

            else {

   253

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

   254

   255

              if (array_initial_element != NULL)

   256

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

   257

            }

   258

            current_initialization_count++;

   259

          }

   260

          break;

   261

        default:

   262

          break;

   263

      }

   264

      return NULL;

   265

    }

   266

   267

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

   268

    /* array_initial_element may be NULL ! */

   269

    void *visit(array_initial_elements_c *symbol) {

   270

      int initial_element_number;

   271

   272

      switch (current_mode) {

   273

        case initializationvalue_am:

   274

          initial_element_number = extract_integer(symbol->integer);

   275

          if (current_initialization_count < defined_values_count) {

   276

            int temp_element_number = 0;

   277

            int diff = defined_values_count - current_initialization_count;

   278

            if (diff <= initial_element_number)

   279

              temp_element_number = initial_element_number - diff;

   280

            current_initialization_count += initial_element_number - 1;

   281

            initial_element_number = temp_element_number;

   282

            if (initial_element_number > 0) {

   283

              defined_values_count++;

   284

              s4o.print(", ");

   285

            }

   286

          }

   287

          else

   288

            current_initialization_count += initial_element_number - 1;

   289

          if (defined_values_count + initial_element_number > array_size)

   290

            ERROR;

   291

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

   292

            if (i > 0)

   293

              s4o.print(", ");

   294

            if (symbol->array_initial_element != NULL)

   295

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

   296

            else

   297

              array_default_value->accept(*this);

   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

      typedecl_sm,

   485

      initializationvalue_sm,

   486

      varlistparse_sm

   487

    } structureinitialization_mode_t;

   488

   489

    structureinitialization_mode_t current_mode;

   490

   491

  private:

   492

    symbol_c* structure_type_decl;

   493

    symbol_c* current_element_type;

   494

   495

  public:

   496

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

   497

    ~generate_c_structure_initialization_c(void) {}

   498