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

   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

	  this->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 (this->current_var_init_symbol != NULL) {

   327

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

   328

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

   329

            s4o.print("(");

   330

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

   331

            s4o.print(")");

   332

          }

   333

        }

   334

      }

   335

   336

      return NULL;

   337

    }

   338

   339

   340

   341

   342

  public:

   343

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

   344

    : generate_cc_typedecl_c(s4o_ptr) {

   345

      wanted_varformat = varformat;

   346

      wanted_vartype   = vartype;

   347

      current_vartype  = none_vt;

   348

      current_var_type_symbol = NULL;

   349

      current_var_init_symbol = NULL;

   350

      globalnamespace         = NULL;

   351

      nv = NULL;

   352

    }

   353

   354

    ~generate_cc_vardecl_c(void) {}

   355

   356

   357

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

   358

      this->set_variable_prefix(variable_prefix);

   359

      if (globalinit_vf == wanted_varformat)

   360

        globalnamespace = scope;

   361

   362

      finterface_var_count = 0;

   363

   364

      switch (wanted_varformat) {

   365

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

   366

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

   367

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

   368

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

   369

	default:                 nv = NULL;

   370

      } /* switch() */

   371

   372

      symbol->accept(*this);

   373

   374

      /* special case... */

   375

      if (wanted_varformat == finterface_vf)

   376

        if (finterface_var_count == 0)

   377

          s4o.print("void");

   378

   379

      delete nv;

   380

      nv = NULL;

   381

      globalnamespace = NULL;

   382

    }

   383

   384

   385

  protected:

   386

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

   387

/* B 0 - Programming Model */

   388

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

   389

  /* leave for derived classes... */

   390

   391

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

   392

/* B.1 - Common elements */

   393

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

   394

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

   395

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

   396

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

   397

  /* done in base class(es) */

   398

   399

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

   400

/* B 1.2 - Constants */

   401

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

   402

  /* originally empty... */

   403

   404

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

   405

/* B 1.2.1 - Numeric Literals */

   406

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

   407

  /* done in base class(es) */

   408

   409

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

   410

/* B.1.2.2   Character Strings */

   411

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

   412

  /* done in base class(es) */

   413

   414

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

   415

/* B 1.2.3 - Time Literals */

   416

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

   417

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

   418

/* B 1.2.3.1 - Duration */

   419

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

   420

  /* done in base class(es) */

   421

   422

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

   423

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

   424

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

   425

  /* done in base class(es) */

   426

   427

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

   428

/* B.1.3 - Data types */

   429

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

   430

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

   431

/* B 1.3.1 - Elementary Data Types */

   432

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

   433

  /* done in base class(es) */

   434

   435

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

   436

/* B.1.3.2 - Generic data types */

   437

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

   438

  /* originally empty... */

   439

   440

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

   441

/* B 1.3.3 - Derived data types */

   442

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

   443

  /* done in base class(es) */

   444

   445

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

   446

/* B 1.4 - Variables */

   447

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

   448

  /* done in base class(es) */

   449

   450

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

   451

/* B.1.4.1   Directly Represented Variables */

   452

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

   453

  /* done in base class(es) */

   454

   455

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

   456

/* B.1.4.2   Multi-element Variables */

   457

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

   458

  /* done in base class(es) */

   459

   460

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

   461

/* B 1.4.3 - Declaration & Initialisation */

   462

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

   463

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

   464

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

   465

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

   466

   467

void *visit(input_declarations_c *symbol) {

   468

  TRACE("input_declarations_c");

   469

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

   470

/*

   471

    // TO DO ...

   472

    if (symbol->option != NULL)

   473

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

   474

*/

   475

    //s4o.indent_right();

   476

    current_vartype = input_vt;

   477

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

   478

    current_vartype = none_vt;

   479

    //s4o.indent_left();

   480

  }

   481

  return NULL;

   482

}

   483

   484

/* helper symbol for input_declarations */

   485

void *visit(input_declaration_list_c *symbol) {

   486

  TRACE("input_declaration_list_c");

   487

  print_list(symbol);

   488

  return NULL;

   489

}

   490

   491

void *visit(edge_declaration_c *symbol) {

   492

  TRACE("edge_declaration_c");

   493

  // TO DO ...

   494

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

   495

  s4o.print(" : BOOL ");

   496

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

   497

  return NULL;

   498

}

   499

   500

void *visit(raising_edge_option_c *symbol) {

   501

  // TO DO ...

   502

  s4o.print("R_EDGE");

   503

  return NULL;

   504

}

   505

   506

   507

#if 0

   508

/* var1_list ':' array_spec_init */

   509

SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   510

#endif

   511

   512

/*  var1_list ':' initialized_structure */

   513

// SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure)

   514

void *visit(structured_var_init_decl_c *symbol) {

   515

  TRACE("structured_var_init_decl_c");

   516

  /* Please read the comments inside the var1_init_decl_c

   517

   * visitor, as they apply here too.

   518

   */

   519

   520

  /* Start off by setting the current_var_type_symbol and

   521

   * current_var_init_symbol private variables...

   522

   */

   523

  update_type_init(symbol->initialized_structure);

   524

   525

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

   526

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

   527

   528

  /* Values no longer in scope, and therefore no longer used.

   529

   * Make an effort to keep them set to NULL when not in use

   530

   * in order to catch bugs as soon as possible...