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,

   203

		    localinit_vf,

   204

		    init_vf,

   205

		    constructorinit_vf,

   206

		    globalinit_vf

   207

		   } varformat_t;

   208

   209

   210

  private:

   211

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

   212

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

   213

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

   214

    unsigned int wanted_vartype;

   215

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

   216

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

   217

    unsigned int current_vartype;

   218

   219

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

   220

     * variables within a function interface...

   221

     */

   222

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

   223

    varformat_t wanted_varformat;

   224

   225

    /* The number of variables already declared. */

   226

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

   227

    int finterface_var_count;

   228

   229

   230

   231

    /* Holds the references to the type and initial value

   232

     * of the variables currently being declared.

   233

     * Please read the comment under var1_init_decl_c for further

   234

     * details...

   235

     *

   236

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

   237

     * whenever we are outside the scope of variable declaration

   238

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

   239

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

   240

     * any bugs as soon as possible.

   241

     */

   242

    symbol_c *current_var_type_symbol;

   243

    symbol_c *current_var_init_symbol;

   244

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

   245

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

   246

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

   247

      if (NULL == this->current_var_type_symbol)

   248

        ERROR;

   249

      if (NULL == this->current_var_init_symbol) {

   250

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

   251

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

   252

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

   253

      /*

   254

      if (NULL == this->current_var_init_symbol)

   255

        ERROR;

   256

      */

   257

      }

   258

    }

   259

   260

    void void_type_init(void) {

   261

      this->current_var_type_symbol = NULL;

   262

      this->current_var_init_symbol = NULL;

   263

    }

   264

   265

    /* Only used when wanted_varformat == globalinit_vf

   266

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

   267

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

   268

     * declared.

   269

     */

   270

    symbol_c *globalnamespace;

   271

   272

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

   273

    /* Note that located variables are the exception, they

   274

     * being declared in the located_var_decl_c visitor...

   275

     */

   276

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

   277

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

   278

      /* should NEVER EVER occur!! */

   279

      if (list == NULL) ERROR;

   280

   281

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

   282

      if ((wanted_varformat == local_vf) ||

   283

          (wanted_varformat == init_vf) ||

   284

          (wanted_varformat == localinit_vf)) {

   285

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

   286

          s4o.print(s4o.indent_spaces);

   287

          if (wanted_varformat != init_vf) {

   288

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

   289

            s4o.print(" ");

   290

          }

   291

          print_variable_prefix();

   292

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

   293

          if (wanted_varformat != local_vf) {

   294

            if (this->current_var_init_symbol != NULL) {

   295

              s4o.print(" = ");

   296

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

   297

            }

   298

          }

   299

          s4o.print(";\n");

   300

        }

   301

      }

   302

   303

      if (wanted_varformat == finterface_vf) {

   304

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

   305

          finterface_var_count++;

   306

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

   307

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

   308

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

   309

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

   310

            s4o.print(" &");

   311

          else

   312

            s4o.print(" ");

   313

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

   314

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

   315

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

   316

           * if none is specified in the ST source code

   317

           */

   318

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

   319

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

   320

           */

   321

        }

   322

      }

   323

   324

      if (wanted_varformat == constructorinit_vf) {

   325

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

   326

          if (is_fb) {

   327

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

   328

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

   329

            s4o.print(FB_INIT_SUFFIX);

   330

            s4o.print("(");

   331

            this->print_variable_prefix();

   332

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

   333

            s4o.print(");");

   334

          }

   335

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

   336

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

   337

            this->print_variable_prefix();

   338

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

   339

            s4o.print(" = ");

   340

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

   341

            s4o.print(";");

   342

          }

   343

        }

   344

      }

   345

   346

      return NULL;

   347

    }

   348

   349

   350

   351

   352

  public:

   353

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

   354

    : generate_cc_typedecl_c(s4o_ptr) {

   355

      wanted_varformat = varformat;

   356

      wanted_vartype   = vartype;

   357

      current_vartype  = none_vt;

   358

      current_var_type_symbol = NULL;

   359

      current_var_init_symbol = NULL;

   360

      globalnamespace         = NULL;

   361

      nv = NULL;

   362

    }

   363

   364

    ~generate_cc_vardecl_c(void) {}

   365

   366

   367

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

   368

      this->set_variable_prefix(variable_prefix);

   369

      if (globalinit_vf == wanted_varformat)

   370

        globalnamespace = scope;

   371

   372

      finterface_var_count = 0;

   373

   374

      switch (wanted_varformat) {

   375

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

   376

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

   377

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

   378

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

   379

        default:                 nv = NULL;

   380

      } /* switch() */

   381

   382

      symbol->accept(*this);

   383

   384

      /* special case... */

   385

      if (wanted_varformat == finterface_vf)

   386

        if (finterface_var_count == 0)

   387

          s4o.print("void");

   388

   389

      delete nv;

   390

      nv = NULL;

   391

      globalnamespace = NULL;

   392

    }

   393

   394

   395

  protected:

   396

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

   397

/* B 0 - Programming Model */

   398

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

   399

  /* leave for derived classes... */

   400

   401

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

   402

/* B.1 - Common elements */

   403

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

   404

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

   405

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

   406

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

   407

  /* done in base class(es) */

   408

   409

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

   410

/* B 1.2 - Constants */

   411

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

   412

  /* originally empty... */

   413

   414

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

   415

/* B 1.2.1 - Numeric Literals */

   416

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

   417

  /* done in base class(es) */

   418

   419

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

   420

/* B.1.2.2   Character Strings */

   421

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

   422

  /* done in base class(es) */

   423

   424

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

   425

/* B 1.2.3 - Time Literals */

   426

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

   427

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

   428

/* B 1.2.3.1 - Duration */

   429

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

   430

  /* done in base class(es) */

   431

   432

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

   433

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

   434

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

   435

  /* done in base class(es) */

   436

   437

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

   438

/* B.1.3 - Data types */

   439

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

   440

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

   441

/* B 1.3.1 - Elementary Data Types */

   442

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

   443

  /* done in base class(es) */

   444

   445

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

   446

/* B.1.3.2 - Generic data types */

   447

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

   448

  /* originally empty... */

   449

   450

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

   451

/* B 1.3.3 - Derived data types */

   452

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

   453

  /* done in base class(es) */

   454

   455

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

   456

/* B 1.4 - Variables */

   457

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

   458

  /* done in base class(es) */

   459

   460

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

   461

/* B.1.4.1   Directly Represented Variables */

   462

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

   463

  /* done in base class(es) */

   464

   465

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

   466

/* B.1.4.2   Multi-element Variables */

   467

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

   468

  /* done in base class(es) */

   469

   470

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

   471

/* B 1.4.3 - Declaration & Initialisation */

   472

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

   473

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

   474

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

   475

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

   476

   477

void *visit(input_declarations_c *symbol) {

   478

  TRACE("input_declarations_c");

   479

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

   480

/*

   481

    // TO DO ...

   482

    if (symbol->option != NULL)

   483

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

   484

*/

   485

    //s4o.indent_right();

   486

    current_vartype = input_vt;

   487

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

   488

    current_vartype = none_vt;

   489

    //s4o.indent_left();

   490

  }

   491

  return NULL;

   492

}

   493

   494

/* helper symbol for input_declarations */

   495

void *visit(input_declaration_list_c *symbol) {

   496

  TRACE("input_declaration_list_c");

   497

  print_list(symbol);

   498

  return NULL;

   499

}

   500

   501

void *visit(edge_declaration_c *symbol) {

   502

  TRACE("edge_declaration_c");

   503

  // TO DO ...

   504

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

   505

  s4o.print(" : BOOL ");

   506

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

   507

  return NULL;

   508

}

   509

   510

void *visit(raising_edge_option_c *symbol) {

   511

  // TO DO ...

   512

  s4o.print("R_EDGE");

   513

  return NULL;

   514

}

   515

   516

   517

#if 0

   518

/* var1_list ':' array_spec_init */

   519

SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   520

#endif

   521

   522

/*  var1_list ':' initialized_structure */

   523

// SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure)

   524

void *visit(structured_var_init_decl_c *symbol) {

   525

  TRACE("structured_var_init_decl_c");