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,

    85

    } arrayinitialization_mode_t;

    86

    87

    arrayinitialization_mode_t current_mode;

    88

    89

    symbol_c* array_base_type;

    90

    symbol_c* array_default_value;

    91

    symbol_c* array_default_initialization;

    92

    93

  private:

    94

    int current_dimension;

    95

    int array_size;

    96

    int defined_values_count;

    97

    int current_initialization_count;

    98

    99

  public:

   100

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

   101

    ~generate_c_array_initialization_c(void) {}

   102

   104

      array_size = 1;

   105

      defined_values_count = 0;

   106

      current_initialization_count = 0;

   107

      array_base_type = array_default_value = array_default_initialization = NULL;

   108

   110

      array_specification->accept(*this);

   111

    }

   112

   113

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

   114

      int i;

   115

   117

   118

      s4o.print("\n");

   119

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

   120

      s4o.indent_right();

   121

      s4o.print(s4o.indent_spaces);

   122

      s4o.print("static const ");

   125

      array_specification->accept(*this);

   127

      s4o.print(" temp = ");

   129

      init_array_values(array_initialization);

   131

      s4o.print(";\n");

   132

      var1_list->accept(*this);

   133

      s4o.indent_left();

   134

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

   135

    }

   136

   137

    void init_array_values(symbol_c *array_initialization) {

   141

      array_initialization->accept(*this);

   143

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

   144

        array_default_initialization->accept(*this);

   145

      if (defined_values_count < array_size) {

   146

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

   147

          if (defined_values_count > 0)

   148

            s4o.print(",");

   149

          array_default_value->accept(*this);

   150

          defined_values_count++;

   151

        }

   152

      }

   155

    }

   156

   157

    void *visit(identifier_c *type_name) {

   158

      symbol_c *type_decl;

   159

      switch (current_mode) {

   161

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

   162

          type_decl = type_symtable.find_value(type_name);

   163

          if (type_decl == type_symtable.end_value())

   164

            /* Type declaration not found!! */

   165

            ERROR;

   166

          type_decl->accept(*this);

   167

          break;

   168

        default:

   169

          print_token(type_name);

   170

          break;

   171

      }

   172

      return NULL;

   173

    }

   174

   175

    void *visit(var1_list_c *symbol) {

   176

      int i, j;

   177

   178

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

   179

        s4o.print(s4o.indent_spaces);

   180

        s4o.print(SET_VAR);

   181

        s4o.print("(");

   182

        print_variable_prefix();

   183

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

   185

      }

   186

      return NULL;

   187

    }

   188

   189

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

   190

/* B 1.3.3 - Derived data types */

   191

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

   192

   193

    /* array_specification [ASSIGN array_initialization] */

   194

    /* array_initialization may be NULL ! */

   195

    void *visit(array_spec_init_c *symbol) {

   196

      switch (current_mode) {

   198

          array_default_initialization = symbol->array_initialization;

   199

          break;

   200

        default:

   201

          break;

   202

      }

   203

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

   204

      return NULL;

   205

    }

   206

   207

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

   208

    void *visit(array_specification_c *symbol) {

   209

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

   210

      switch (current_mode) {

   212

          array_base_type = symbol->non_generic_type_name;

   213

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

   214

          if (array_default_value == NULL) ERROR;

   215

          break;

   216

        default:

   217

          break;

   218

      } 

   219

      return NULL;

   220

    }

   221

   222

    /*  signed_integer DOTDOT signed_integer */

   223

    //SYM_REF2(subrange_c, lower_limit, upper_limit)

   224

    void *visit(subrange_c *symbol) {

   225

      switch (current_mode) {

   227

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

   228

          break;

   229

        default:

   230

          break;

   231

      }

   232

      return NULL;

   233

    }

   234

   235

    /* helper symbol for array_initialization */

   236

    /* array_initial_elements_list ',' array_initial_elements */

   237

    void *visit(array_initial_elements_list_c *symbol) {

   238

      switch (current_mode) {

   239

        case initializationvalue_am:

   240

          current_initialization_count = 0;

   241

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

   242

            if (current_initialization_count >= defined_values_count) {

   243

              if (defined_values_count >= array_size)

   244

                ERROR;

   245

              if (defined_values_count > 0)

   246

                s4o.print(",");

   247

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

   248

              defined_values_count++;

   249

            }

   250

            else {

   251

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

   252

   253

              if (array_initial_element != NULL) {

   254

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

   255

              }

   256

            }

   257

            current_initialization_count++;

   258

          }

   259

          break;

   260

        default:

   261

          break;

   262

      }

   263

      return NULL;

   264

    }

   265

   266

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

   267

    /* array_initial_element may be NULL ! */

   268

    void *visit(array_initial_elements_c *symbol) {

   269

      int initial_element_number;

   270

   271

      switch (current_mode) {

   272

        case initializationvalue_am:

   273

          initial_element_number = extract_integer(symbol->integer);

   274

          if (current_initialization_count < defined_values_count) {

   275

            int temp_element_number = 0;

   276

            int diff = defined_values_count - current_initialization_count;

   277

            if (diff <= initial_element_number)

   278

              temp_element_number = initial_element_number - diff;

   279

            current_initialization_count += initial_element_number - 1;

   280

            initial_element_number = temp_element_number;

   281

            if (initial_element_number > 0) {

   282

              defined_values_count++;

   283

              s4o.print(",");

   284

            }

   285

          }

   286

          else

   287

            current_initialization_count += initial_element_number - 1;

   288

          if (defined_values_count + initial_element_number > array_size)

   289

            ERROR;

   290

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

   291

            if (i > 0)

   292

              s4o.print(",");

   293

            if (symbol->array_initial_element != NULL) {

   294

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

   295

            }

   296

            else {

   297

              array_default_value->accept(*this);

   298

            }

   299

          }

   300

          if (initial_element_number > 1)

   301

            defined_values_count += initial_element_number - 1;

   302

          break;

   303

        default:

   304

          break;

   305

      }

   306

      return NULL;

   307

    }

   308

   309

    void *visit(structure_element_initialization_list_c *symbol);

   310

};

   311

   312

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

   313

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

   314

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

   315

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

   316

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

   317

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

   318

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

   319

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

   320

   321

/* given a structure_element_declaration_list_c, iterate 

   322

 * through each element, returning the name

   323

 * of each element...structure_element_iterator_c

   324

 */

   325

class structure_element_iterator_c : public null_visitor_c {

   326

   327

  private:

   328

    /* a pointer to the structure_element_declaration_list_c

   329

     * currently being analysed.

   330

     */

   331

    symbol_c *type_decl;

   332

    int next_element, element_count;

   333

    identifier_c *current_element_name;

   334

    symbol_c *current_element_type;

   335

    symbol_c *current_element_default_value;

   336

   337

   338

  public:

   339

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

   340

    void reset(void) {

   341

      next_element = element_count = 0;

   342

      current_element_name = NULL;

   343

      current_element_type = current_element_default_value = NULL;

   344

    }

   345

   346

    /* initialise the iterator object.

   347

     * We must be given a reference to the function declaration

   348

     * that will be analysed...

   349

     */

   350

    structure_element_iterator_c(symbol_c *type_decl) {

   351

      this->type_decl = type_decl;

   352

      reset();

   353

    }

   354

   355

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

   356

     * the object references on 

   357

     * element _before_ the first, so

   358

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

   359

     * reference the first element...

   360

     *

   361

     * Returns the element's name!

   362

     */

   363

    identifier_c *next(void) {

   364

      void *res;

   365

      identifier_c *identifier;

   366

      element_count = 0;

   367

      next_element++;

   368

      res = type_decl->accept(*this);

   369

      if (res != NULL) {

   370

        symbol_c *sym = (symbol_c *)res;

   371

        identifier = dynamic_cast<identifier_c *>(sym);

   372

        if (identifier == NULL)

   373

          ERROR;

   374

      }

   375

      else

   376

        return NULL;

   377

   378

      current_element_name = identifier;

   379

      return current_element_name;

   380

    }

   381

   382

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

   383

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

   384

     */

   385

    symbol_c *default_value(void) {

   386

      return current_element_default_value;

   387

    }

   388

   389

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

   390

    symbol_c *element_type(void) {

   391

      return current_element_type;

   392

    }

   393

   394

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

   395

/* B 1.3.3 - Derived data types */

   396

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

   397

   398

    /* helper symbol for structure_declaration */

   399

    /* structure_element_declaration_list structure_element_declaration ';' */

   400

    void *visit(structure_element_declaration_list_c *symbol) {

   401

      void *res;

   402

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

   403

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

   404

        if (res != NULL)

   405

          return res;

   406

      }

   407

      return NULL;

   408

    }

   409

   410

    /*  structure_element_name ':' *_spec_init */

   411

    void *visit(structure_element_declaration_c *symbol) {

   412

      element_count++;

   413

      if (next_element == element_count) {

   414

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

   415

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

   416

        return symbol->structure_element_name;

   417

      }

   418

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

   419

      return NULL;

   420

    }

   421

   422

};

   423

   424

/*

   425

 * Structure init element iterator.

   426

 * It will search through the elements of a structure initialization

   427

 */

   428

class structure_init_element_iterator_c : public null_visitor_c {

   429

  private:

   430

    /* a pointer to the structure initialization

   431

     * currently being analysed.

   432

     */

   433

    symbol_c *structure_initialization;

   434

    identifier_c *search_element_name;

   435

   436

  public:

   437

    /* initialise the iterator object.

   438

     * We must be given a reference to the structure initialization

   439

     * that will be analysed...

   440

     */

   441

    structure_init_element_iterator_c(symbol_c *structure_initialization) {

   442

      this->structure_initialization = structure_initialization;

   443

      search_element_name = NULL;

   444

    }

   445

   446

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

   447

    symbol_c *search(symbol_c *element_name) {

   448

      if (NULL == element_name) ERROR;

   449

      search_element_name = dynamic_cast<identifier_c *>(element_name);

   450

      if (NULL == search_element_name) ERROR;

   451

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

   452

      return (symbol_c *)res;

   453

    }

   454

   455

    /* helper symbol for structure_initialization */

   456

    /* structure_element_initialization_list ',' structure_element_initialization */

   457

    void *visit(structure_element_initialization_list_c *symbol) {

   458

      void *res;

   459

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

   460

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

   461

        if (res != NULL)

   462

          return res;

   463

      }

   464

      return NULL;

   465

    }

   466

   467

    /*  structure_element_name ASSIGN value */

   468

    void *visit(structure_element_initialization_c *symbol) {

   469

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

   470

   471

      if (element_name == NULL) ERROR;

   472

   473

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

   474

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

   475

        return (void *)symbol->value;

   476

      return NULL;

   477

    }

   478

};

   479

   480

class generate_c_structure_initialization_c: public generate_c_typedecl_c {

   481

   482

  public:

   483

    typedef enum {

   484

      none_sm,

   486

      typedecl_sm,

   488

    } structureinitialization_mode_t;

   489

   490

    structureinitialization_mode_t current_mode;

   491

   492

  private:

   493

    symbol_c* structure_type_decl;

   494

    symbol_c* current_element_type;

   495