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_default_value;

    60

    61

  private:

    62

    int dimension_number, current_dimension, array_size;

    63

    64

  public:

    65

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

    66

    ~generate_c_array_initialization_c(void) {}

    67

    68

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

    69

      int i;

    70

    71

      dimension_number = 0;

    72

      current_dimension = 0;

    73

      array_size = 1;

    74

      array_default_value = NULL;

    75

    76

      current_mode = dimensioncount_am;

    77

      array_specification->accept(*this);

    78

    79

      current_mode = initializationvalue_am;

    80

      s4o.print("\n");

    81

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

    82

      s4o.indent_right();

    83

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

    84

      print_integer(dimension_number);

    85

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

    86

      s4o.print(s4o.indent_spaces);

    87

      array_specification->accept(*this);

    88

      s4o.print(" temp = ");

    89

      array_initialization->accept(*this);

    90

      s4o.print(";\n");

    91

    92

      current_mode = arrayassignment_am;

    93

      array_specification->accept(*this);

    94

    95

      current_mode = varlistparse_am;

    96

      var1_list->accept(*this);

    97

    98

      current_mode = arrayassignment_am;

    99

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

   100

        s4o.indent_left();

   101

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

   102

      }

   103

      s4o.indent_left();

   104

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

   105

    }

   106

   107

    void *visit(identifier_c *type_name) {

   108

      symbol_c *type_decl;

   109

      switch (current_mode) {

   110

        case dimensioncount_am:

   111

        case arrayassignment_am:

   112

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

   113

          type_decl = type_symtable.find_value(type_name);

   114

          if (type_decl == type_symtable.end_value())

   115

            /* Type declaration not found!! */

   116

            ERROR;

   117

          type_decl->accept(*this);

   118

          break;

   119

        default:

   120

          print_token(type_name);

   121

          break;

   122

      }

   123

      return NULL;

   124

    }

   125

   126

    void *visit(var1_list_c *symbol) {

   127

      int i, j;

   128

   129

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

   130

        s4o.print(s4o.indent_spaces);

   131

        print_variable_prefix();

   132

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

   133

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

   134

          s4o.print("[index[");

   135

          print_integer(j);

   136

          s4o.print("]]");

   137

        }

   138

        s4o.print(" = temp");

   139

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

   140

          s4o.print("[index[");

   141

          print_integer(j);

   142

          s4o.print("]]");

   143

        }

   144

        s4o.print(";\n");

   145

      }

   146

      return NULL;

   147

    }

   148

   149

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

   150

/* B 1.3.3 - Derived data types */

   151

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

   152

   153

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

   154

    void *visit(array_specification_c *symbol) {

   155

      switch (current_mode) {

   156

        case dimensioncount_am:

   157

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

   158

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

   159

          break;

   160

        default:

   161

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

   162

          break;

   163

      } 

   164

      return NULL;

   165

    }

   166

   167

    /*  signed_integer DOTDOT signed_integer */

   168

    //SYM_REF2(subrange_c, lower_limit, upper_limit)

   169

    void *visit(subrange_c *symbol) {

   170

      switch (current_mode) {

   171

        case dimensioncount_am:

   172

          dimension_number++;

   173

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

   174

          break;

   175

        case arrayassignment_am:

   176

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

   177

          print_integer(current_dimension);

   178

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

   179

          print_integer(current_dimension);

   180

          s4o.print("] <= ");

   181

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

   182

          s4o.print("; index[");

   183

          print_integer(current_dimension);

   184

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

   185

          s4o.indent_right();

   186

          current_dimension++;

   187

          break;

   188

        default:

   189

          break;

   190

      }

   191

      return NULL;

   192

    }

   193

   194

    /* helper symbol for array_initialization */

   195

    /* array_initial_elements_list ',' array_initial_elements */

   196

    void *visit(array_initial_elements_list_c *symbol) {

   197

      switch (current_mode) {

   198

        case initializationvalue_am:

   199

          int i;

   200

   201

          s4o.print("{");

   202

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

   203

            if (i > 0)

   204

              s4o.print(", ");

   205

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

   206

            array_size--;

   207

          }

   208

          if (array_size > 0) {

   209

            if (symbol->n > 0)

   210

              s4o.print(", ");

   211

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

   212

              if (i > 0)

   213

                s4o.print(", ");

   214

              array_default_value->accept(*this);

   215

            }

   216

          }

   217

          s4o.print("}");

   218

          break;

   219

        default:

   220

          break;

   221

      }

   222

      return NULL;

   223

    }

   224

   225

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

   226

    /* array_initial_element may be NULL ! */

   227

    void *visit(array_initial_elements_c *symbol) {

   228

      int initial_element_number;

   229

   230

      switch (current_mode) {

   231

        case initializationvalue_am:

   232

          initial_element_number = extract_integer(symbol->integer);

   233

   234

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

   235

            if (i > 0)

   236

              s4o.print(", ");

   237

            if (symbol->array_initial_element != NULL)

   238

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

   239

            else if (array_default_value != NULL)

   240

              array_default_value->accept(*this);

   241

          }

   242

          if (initial_element_number > 1)

   243

            array_size -= initial_element_number - 1;

   244

          break;

   245

        default:

   246

          break;

   247

      }

   248

      return NULL;

   249

    }

   250

   251

};

   252

   253

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

   254

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

   255

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

   256

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

   257

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

   258

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

   259

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

   260

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

   261

   262

   263

   264

   265

class generate_c_vardecl_c: protected generate_c_typedecl_c {

   266

   267

  /* A Helper class to the main class... */

   268

  /* print a string, except the first time it is called */

   269

  /* used to print the separator "," before each variable

   270

   * declaration, except the first...

   271

   *

   272

   * Needs to be done in a seperate class because this is called

   273

   * from within various locations within the code.

   274

   */

   275

  class next_var_c {

   276

    private:

   277

      bool print_flag;

   278

      std::string str1, str2;

   279

   280

      next_var_c *embedded_scope;

   281

   282

    public:

   283

      next_var_c(std::string s1, std::string s2) {

   284

        str1 = s1;

   285

        str2 = s2;

   286

        print_flag = false;

   287

        embedded_scope = NULL;

   288

      }

   289

   290

      std::string get(void) {

   291

        if (NULL != embedded_scope)

   292

          return embedded_scope->get();

   293

   294

        bool old_print_flag = print_flag;

   295

        print_flag = true;

   296

        if (!old_print_flag)

   297

          return str1;

   298

        else

   299

          return str2;

   300

      }

   301

   302

      /* Create a new next_var_c for an embedded scope.

   303

       * From now on, every call to get() will return the

   304

       * inner-most scope...!

   305

       */

   306

      void push(std::string s1, std::string s2) {

   307

        if (NULL != embedded_scope)

   308

          return embedded_scope->push(s1, s2);

   309

   310

        embedded_scope = new next_var_c(s1, s2);

   311

        if (NULL == embedded_scope)

   312

          ERROR;

   313

        return;

   314

      }

   315

   316

      /* Remove the inner-most scope... */

   317

      void pop(void) {

   318

        if (NULL != embedded_scope)

   319

          return embedded_scope->pop();

   320

   321

        delete embedded_scope;

   322

        embedded_scope = NULL;

   323

      }

   324

  };

   325

   326

  private:

   327

    /* used to generate the ',' separating the parameters in a function call */

   328

    next_var_c *nv;

   329

   330

   331

  public:

   332

    /* the types of variables that need to be processed... */

   333

    static const unsigned int none_vt	  = 0x0000;

   334

    static const unsigned int input_vt	  = 0x0001;  // VAR_INPUT

   335

    static const unsigned int output_vt	  = 0x0002;  // VAR_OUTPUT

   336

    static const unsigned int inoutput_vt = 0x0004;  // VAR_IN_OUT

   337

    static const unsigned int private_vt  = 0x0008;  // VAR

   338

    static const unsigned int temp_vt	  = 0x0010;  // VAR_TEMP

   339

    static const unsigned int external_vt = 0x0020;  // VAR_EXTERNAL

   340

    static const unsigned int global_vt   = 0x0040;  // VAR_GLOBAL

   341

						     //    Globals declared inside a resource will not be declared

   342

						     //    unless global_vt is acompanied by resource_vt

   343

    static const unsigned int located_vt  = 0x0080;  // VAR <var_name> AT <location>

   344

    static const unsigned int program_vt  = 0x0100;  // PROGRAM (inside a configuration!)

   345

						     //    Programs declared inside a resource will not be declared

   346

						     //    unless program_vt is acompanied by resource_vt

   347

   348

    static const unsigned int resource_vt = 0x8000;  // RESOURCE (inside a configuration!)

   349

                                                     //    This, just of itself, will not print out any declarations!!

   350

						     //    It must be acompanied by either program_vt and/or global_vt

   351

   352

    /* How variables should be declared: as local variables or

   353

     * variables within a function call interface.

   354

     *

   355

     * This will define the format of the output generated

   356

     * by this class.

   357

     *

   358

     * finterface_vf: function interface parameters

   359

     *               e.g.  f(  int a, long b, real c );

   360

     *                         ---------------------

   361

     *               This class/function will produce the

   362

     *               underlined code of the above examples,

   363

     *               and no more!!

   364

     *

   365

     * localinit_vf: local declaration. Will include variable

   366

     *           initialisation if it is not a located variable.

   367

     *           e.g.

   368

     *                int a = 9;

   369

     *                long b = 99;

   370

     *                real c = 99.9;

   371

     *

   372

     * local_vf: local declaration. Will NOT include variable

   373

     *           initialisation.

   374

     *           e.g.

   375

     *                int a;

   376

     *                long b;

   377

     *                real c;

   378

     *

   379

     * init_vf: local initialisation without declaration.

   380

     *           e.g.

   381

     *                a = 9;

   382

     *                b = 99;

   383

     *                c = 99.9;

   384

     *

   385

     * constructorinit_vf: initialising of member variables...

   386

     *                e.g. for a constructor...

   387

     *                class_name_c(void)

   388

     *                : a(9), b(99), c(99.9)  { // code... }

   389

     *                  --------------------

   390

     *               This class/function will produce the

   391

     *               underlined code of the above examples,

   392

     *               and no more!!

   393

     *

   394

     * globalinit_vf: initialising of static c++ variables. These

   395

     *                variables may have been declared as static inside

   396

     *                a class, in which case the scope within which they were

   397

     *                previously delcared must be passed as the second parameter

   398

     *                to the print() function.

   399

     *

   400

     *                e.g.

   401

     *                __plc_pt_c<INT, 8*sizeof(INT)> START_P::loc = __plc_pt_c<INT, 8*sizeof(INT)>("I2");

   402

     */

   403

    typedef enum {finterface_vf,

   404

                    local_vf,

   405

		    localinit_vf,

   406

		    init_vf,

   407

		    constructorinit_vf,

   408

		    globalinit_vf

   409

		   } varformat_t;

   410

   411

   412

  private:

   413

    generate_c_array_initialization_c *generate_c_array_initialization;

   414

   415

    /* variable used to store the types of variables that need to be processed... */

   416

    /* Only set in the constructor...! */

   417

    /* Will contain a set of values of generate_c_vardecl_c::XXXX_vt */

   418

    unsigned int wanted_vartype;

   419

    /* variable used to store the type of variable currently being processed... */

   420

    /* Will contain a single value of generate_c_vardecl_c::XXXX_vt */

   421

    unsigned int current_vartype;

   422

   423

    /* How variables should be declared: as local variables or

   424

     * variables within a function interface...

   425

     */

   426

    /* Only set in the constructor...! */

   427

    varformat_t wanted_varformat;

   428

   429

    /* The number of variables already declared. */

   430

    /* Used to declare 'void' in case no variables are declared in a function interface... */

   431

    int finterface_var_count;

   432

   433

   434

   435

    /* Holds the references to the type and initial value

   436

     * of the variables currently being declared.

   437

     * Please read the comment under var1_init_decl_c for further

   438

     * details...

   439

     *

   440

     * We make an effort to keep these pointers pointing to NULL

   441

     * whenever we are outside the scope of variable declaration

   442

     * (i.e. when we are traversing a part of the parse tree which

   443

     * is not part of variable declaration) in order tio try to catch

   444

     * any bugs as soon as possible.

   445

     */

   446

    symbol_c *current_var_type_symbol;

   447

    symbol_c *current_var_init_symbol;

   448

    void update_type_init(symbol_c *symbol /* a spec_init_c, subrange_spec_init_c, etc... */ ) {

   449

      this->current_var_type_symbol = spec_init_sperator_c::get_spec(symbol);

   450

      this->current_var_init_symbol = spec_init_sperator_c::get_init(symbol);

   451

      if (NULL == this->current_var_type_symbol)

   452

        ERROR;

   453

      if (NULL == this->current_var_init_symbol) {

   454

        /* We try to find the data type's default value... */

   455

        this->current_var_init_symbol = (symbol_c *)this->current_var_type_symbol->accept(*type_initial_value_c::instance());

   456

      /* Note that Function Block 'data types' do not have a default value, so we cannot abort if no default value is found! */

   457

      /*

   458

      if (NULL == this->current_var_init_symbol)

   459

        ERROR;

   460

      */

   461

      }

   462

    }

   463

   464

    void void_type_init(void) {

   465

      this->current_var_type_symbol = NULL;

   466

      this->current_var_init_symbol = NULL;

   467

    }

   468

   469

    /* Only used when wanted_varformat == globalinit_vf

   470

     * Holds a pointer to an identifier_c, which in turns contains

   471

     * the identifier of the scope within which the static member was

   472

     * declared.

   473

     */

   474

    symbol_c *globalnamespace;

   475

   476

    /* Actually produce the output where variables are declared... */

   477

    /* Note that located variables are the exception, they

   478

     * being declared in the located_var_decl_c visitor...

   479

     */

   480

    void *declare_variables(symbol_c *symbol, bool is_fb = false) {

   481

      list_c *list = dynamic_cast<list_c *>(symbol);

   482

      /* should NEVER EVER occur!! */

   483

      if (list == NULL) ERROR;

   484

   485

      /* now to produce the c equivalent... */

   486

      if ((wanted_varformat == local_vf) ||

   487

          (wanted_varformat == init_vf) ||

   488

          (wanted_varformat == localinit_vf)) {

   489

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

   490

          s4o.print(s4o.indent_spaces);

   491

          if (wanted_varformat != init_vf) {

   492

            this->current_var_type_symbol->accept(*this);

   493

            s4o.print(" ");

   494

          }

   495

          print_variable_prefix();

   496

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

   497

          if (wanted_varformat != local_vf) {

   498

            if (this->current_var_init_symbol != NULL) {

   499

              s4o.print(" = ");

   500

              this->current_var_init_symbol->accept(*this);

   501

            }

   502

          }

   503

          s4o.print(";\n");

   504

        }

   505

      }

   506

   507

      if (wanted_varformat == finterface_vf) {

   508

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

   509

          finterface_var_count++;

   510

          s4o.print(nv->get());

   511

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

   512

          this->current_var_type_symbol->accept(*this);

   513

          if ((current_vartype & (output_vt | inoutput_vt)) != 0)

   514

            s4o.print(" &");

   515

          else