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

    47

    48

    49

    50

    51

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

    52

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

    53

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

    54

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

    55

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

    56

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

    57

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

    58

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

    59

    60

    61

    62

    63

class generate_cc_vardecl_c: protected generate_cc_typedecl_c {

    64

    65

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

    66

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

    67

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

    68

   * declaration, except the first...

    69

   *

    70

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

    71

   * from within various locations within the code.

    72

   */

    73

  class next_var_c {

    74

    private:

    75

      bool print_flag;

    76

      std::string str1, str2;

    77

    78

      next_var_c *embedded_scope;

    79

    80

    public:

    81

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

    82

        str1 = s1;

    83

        str2 = s2;

    84

        print_flag = false;

    85

        embedded_scope = NULL;

    86

      }

    87

    88

      std::string get(void) {

    89

        if (NULL != embedded_scope)

    90

          return embedded_scope->get();

    91

    92

        bool old_print_flag = print_flag;

    93

        print_flag = true;

    94

        if (!old_print_flag)

    95

          return str1;

    96

        else

    97

          return str2;

    98

      }

    99

   100

      /* Create a new next_var_c for an embedded scope.

   101

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

   102

       * inner-most scope...!

   103

       */

   104

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

   105

        if (NULL != embedded_scope)

   106

          return embedded_scope->push(s1, s2);

   107

   108

        embedded_scope = new next_var_c(s1, s2);

   109

        if (NULL == embedded_scope)

   110

          ERROR;

   111

        return;

   112

      }

   113

   114

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

   115

      void pop(void) {

   116

        if (NULL != embedded_scope)

   117

          return embedded_scope->pop();

   118

   119

        delete embedded_scope;

   120

        embedded_scope = NULL;

   121

      }

   122

  };

   123

   124

  private:

   125

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

   126

    next_var_c *nv;

   127

   128

   129

  public:

   130

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

   131

    static const unsigned int none_vt	  = 0x0000;

   132

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

   133

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

   134

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

   135

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

   136

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

   137

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

   138

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

   139

						     //    Globals declared inside a resource will not be declared

   140

						     //    unless global_vt is acompanied by resource_vt

   141

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

   142

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

   143

						     //    Programs declared inside a resource will not be declared

   144

						     //    unless program_vt is acompanied by resource_vt

   145

   146

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

   147

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

   148

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

   149

   150

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

   151

     * variables within a function call interface.

   152

     *

   153

     * This will define the format of the output generated

   154

     * by this class.

   155

     *

   156

     * finterface_vf: function interface parameters

   157

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

   158

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

   159

     *               This class/function will produce the

   160

     *               underlined code of the above examples,

   161

     *               and no more!!

   162

     *

   163

     * localinit_vf: local declaration. Will include variable

   164

     *           initialisation if it is not a located variable.

   165

     *           e.g.

   166

     *                int a = 9;

   167

     *                long b = 99;

   168

     *                real c = 99.9;

   169

     *

   170

     * local_vf: local declaration. Will NOT include variable

   171

     *           initialisation.

   172

     *           e.g.

   173

     *                int a;

   174

     *                long b;

   175

     *                real c;

   176

     *

   177

     * init_vf: local initialisation without declaration.

   178

     *           e.g.

   179

     *                a = 9;

   180

     *                b = 99;

   181

     *                c = 99.9;

   182

     *

   183

     * constructorinit_vf: initialising of member variables...

   184

     *                e.g. for a constructor...

   185

     *                class_name_c(void)

   186

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

   187

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

   188

     *               This class/function will produce the

   189

     *               underlined code of the above examples,

   190

     *               and no more!!

   191

     *

   192

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

   193

     *                variables may have been declared as static inside

   194

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

   195

     *                previously delcared must be passed as the second parameter

   196

     *                to the print() function.

   197

     *

   198

     *                e.g.

   199

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

   200

     */

   201

    typedef enum {finterface_vf,

   202

                    local_vf,

   204

		    localinit_vf,

   205

		    init_vf,

   206

		    constructorinit_vf,

   207

		    globalinit_vf

   208

		   } varformat_t;

   209

   210

   211

  private:

   212

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

   213

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

   214

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

   215

    unsigned int wanted_vartype;

   216

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

   217

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

   218

    unsigned int current_vartype;

   219

   220

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

   221

     * variables within a function interface...

   222

     */

   223

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

   224

    varformat_t wanted_varformat;

   225

   226

    /* The number of variables already declared. */

   227

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

   228

    int finterface_var_count;

   229

   230

   231

   232

    /* Holds the references to the type and initial value

   233

     * of the variables currently being declared.

   234

     * Please read the comment under var1_init_decl_c for further

   235

     * details...

   236

     *

   237

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

   238

     * whenever we are outside the scope of variable declaration

   239

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

   240

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

   241

     * any bugs as soon as possible.

   242

     */

   243

    symbol_c *current_var_type_symbol;

   244

    symbol_c *current_var_init_symbol;

   245

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

   246

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

   247

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

   248

      if (NULL == this->current_var_type_symbol)

   249

        ERROR;

   250

      if (NULL == this->current_var_init_symbol) {

   251

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

   252

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

   253

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

   254

      /*

   255

      if (NULL == this->current_var_init_symbol)

   256

        ERROR;

   257

      */

   258

      }

   259

    }

   260

   261

    void void_type_init(void) {

   262

      this->current_var_type_symbol = NULL;

   263

      this->current_var_init_symbol = NULL;

   264

    }

   265

   266

    /* Only used when wanted_varformat == globalinit_vf

   267

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

   268

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

   269

     * declared.

   270

     */

   271

    symbol_c *globalnamespace;

   272

   273

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

   274

    /* Note that located variables are the exception, they

   275

     * being declared in the located_var_decl_c visitor...

   276

     */

   277

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

   278

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

   279

      /* should NEVER EVER occur!! */

   280

      if (list == NULL) ERROR;

   281

   282

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

   283

      if ((wanted_varformat == local_vf) ||

   284

          (wanted_varformat == init_vf) ||

   285

          (wanted_varformat == localinit_vf)) {

   286

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

   287

          s4o.print(s4o.indent_spaces);

   288

          if (wanted_varformat != init_vf) {

   289

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

   290

            s4o.print(" ");

   291

          }

   292

          print_variable_prefix();

   293

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

   294

          if (wanted_varformat != local_vf) {

   295

            if (this->current_var_init_symbol != NULL) {

   296

              s4o.print(" = ");

   297

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

   298

            }

   299

          }

   300

          s4o.print(";\n");

   301

        }

   302

      }

   303

   304

      if (wanted_varformat == finterface_vf) {

   305

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

   306

          finterface_var_count++;

   307

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

   308

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

   309

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

   310

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

   311

            s4o.print(" &");

   312

          else

   313

            s4o.print(" ");

   314

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

   315

          /* We do not print the initial value at function declaration!

   316

           * It is up to the caller to pass the correct default value

   317

           * if none is specified in the ST source code

   318

           */

   319

          /* if (this->current_var_init_symbol != NULL) {

   320

               s4o.print(" = "); this->current_var_init_symbol->accept(*this);}

   321

           */

   322

        }

   323

      }

   324

   325

      if (wanted_varformat == constructorinit_vf) {

   326

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

   327

          if (is_fb) {

   328

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

   329

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

   330

            s4o.print(FB_INIT_SUFFIX);

   332

            this->print_variable_prefix();

   333

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

   334

            s4o.print(");");

   335

          }

   336

          else if (this->current_var_init_symbol != NULL) {

   337

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

   338

            this->print_variable_prefix();

   339

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

   340

            s4o.print(" = ");

   341

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

   342

            s4o.print(";");

   343

          }

   344

        }

   345

      }

   346

   347

      return NULL;

   348

    }

   349

   350

   351

   352

   353

  public:

   354

    generate_cc_vardecl_c(stage4out_c *s4o_ptr, varformat_t varformat, unsigned int vartype)

   355

    : generate_cc_typedecl_c(s4o_ptr) {

   356

      wanted_varformat = varformat;

   357

      wanted_vartype   = vartype;

   358

      current_vartype  = none_vt;

   359

      current_var_type_symbol = NULL;

   360

      current_var_init_symbol = NULL;

   361

      globalnamespace         = NULL;

   362

      nv = NULL;

   363

    }

   364

   365

    ~generate_cc_vardecl_c(void) {}

   366

   367

   368

    void print(symbol_c *symbol, symbol_c *scope = NULL, const char *variable_prefix = NULL) {

   369

      this->set_variable_prefix(variable_prefix);

   370

      if (globalinit_vf == wanted_varformat)

   371

        globalnamespace = scope;

   372

   373

      finterface_var_count = 0;

   374

   375

      switch (wanted_varformat) {

   376

        case constructorinit_vf: nv = new next_var_c("", "\n"+s4o.indent_spaces); break;

   377

        case finterface_vf:      /* fall through... */

   378

        case localinit_vf:       /* fall through... */

   379

        case local_vf:           nv = new next_var_c("", ", "); break;

   380

        default:                 nv = NULL;

   381

      } /* switch() */

   382

   383

      symbol->accept(*this);

   384

   385

      /* special case... */

   386

      if (wanted_varformat == finterface_vf)

   387

        if (finterface_var_count == 0)

   388

          s4o.print("void");

   389

   390

      delete nv;

   391

      nv = NULL;

   392

      globalnamespace = NULL;

   393

    }

   394

   395

   396

  protected:

   397

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

   398

/* B 0 - Programming Model */

   399

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

   400

  /* leave for derived classes... */

   401

   402

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

   403

/* B.1 - Common elements */

   404

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

   405

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

   406

/* B 1.1 - Letters, digits and identifiers */

   407

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

   408

  /* done in base class(es) */

   409

   410

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

   411

/* B 1.2 - Constants */

   412

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

   413

  /* originally empty... */

   414

   415

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

   416

/* B 1.2.1 - Numeric Literals */

   417

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

   418

  /* done in base class(es) */

   419

   420

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

   421

/* B.1.2.2   Character Strings */

   422

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

   423

  /* done in base class(es) */

   424

   425

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

   426

/* B 1.2.3 - Time Literals */

   427

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

   428

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

   429

/* B 1.2.3.1 - Duration */

   430

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

   431

  /* done in base class(es) */

   432

   433

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

   434

/* B 1.2.3.2 - Time of day and Date */

   435

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

   436

  /* done in base class(es) */

   437

   438

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

   439

/* B.1.3 - Data types */

   440

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

   441

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

   442

/* B 1.3.1 - Elementary Data Types */

   443

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

   444

  /* done in base class(es) */

   445

   446

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

   447

/* B.1.3.2 - Generic data types */

   448

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

   449

  /* originally empty... */

   450

   451

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

   452

/* B 1.3.3 - Derived data types */

   453

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

   454

  /* done in base class(es) */

   455

   456

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

   457

/* B 1.4 - Variables */

   458

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

   459

  /* done in base class(es) */

   460

   461

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

   462

/* B.1.4.1   Directly Represented Variables */

   463

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

   464

  /* done in base class(es) */

   465

   466

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

   467

/* B.1.4.2   Multi-element Variables */

   468

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

   469

  /* done in base class(es) */

   470

   471

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

   472

/* B 1.4.3 - Declaration & Initialisation */

   473

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

   474

void *visit(constant_option_c *symbol) {s4o.print("CONSTANT"); return NULL;}

   475

void *visit(retain_option_c *symbol) {s4o.print("RETAIN"); return NULL;}

   476

void *visit(non_retain_option_c *symbol) {s4o.print("NON_RETAIN"); return NULL;}

   477

   478

void *visit(input_declarations_c *symbol) {

   479

  TRACE("input_declarations_c");

   480

  if ((wanted_vartype & input_vt) != 0) {

   481

/*

   482

    // TO DO ...

   483

    if (symbol->option != NULL)

   484

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

   485

*/

   486

    //s4o.indent_right();

   487

    current_vartype = input_vt;

   488

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

   489

    current_vartype = none_vt;

   490

    //s4o.indent_left();

   491

  }

   492

  return NULL;

   493

}

   494

   495

/* helper symbol for input_declarations */

   496

void *visit(input_declaration_list_c *symbol) {

   497

  TRACE("input_declaration_list_c");

   498

  print_list(symbol);

   499

  return NULL;

   500

}

   501

   502

void *visit(edge_declaration_c *symbol) {

   503

  TRACE("edge_declaration_c");

   504

  // TO DO ...

   505

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

   506

  s4o.print(" : BOOL ");

   507

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

   508

  return NULL;

   509

}

   510

   511

void *visit(raising_edge_option_c *symbol) {

   512

  // TO DO ...

   513

  s4o.print("R_EDGE");

   514

  return NULL;

   515

}

   516

   517

   518

#if 0

   519

/* var1_list ':' array_spec_init */

   520

SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   521

#endif

   522

   523

/*  var1_list ':' initialized_structure */

   524

// SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure)

   525

void *visit(structured_var_init_decl_c *symbol) {