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 il statements (i.e. IL code).

    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

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

    38

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

    39

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

    40

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

    41

    42

/* Returns the data type of an il_operand.

    43

 *

    44

 * Note that the il_operand may be a variable, in which case

    45

 * we return the type of the variable instance.

    46

 * The il_operand may also be a constant, in which case

    47

 * we return the data type of that constant.

    48

 *

    49

 * The variable instance may be a member of a structured variable,

    50

 * or an element in an array, or any combination of the two.

    51

 *

    52

 * The class constructor must be given the search scope

    53

 * (function, function block or program within which

    54

 * the possible il_operand variable instance was declared).

    55

 */

    56

    57

class search_il_operand_type_c {

    58

    59

  private:

    60

    search_varfb_instance_type_c search_varfb_instance_type;

    61

    search_constant_type_c search_constant_type;

    62

    63

  public:

    64

    search_il_operand_type_c(symbol_c *search_scope): search_varfb_instance_type(search_scope) {}

    65

    66

  public:

    67

    symbol_c *get_type(symbol_c *il_operand) {

    68

      symbol_c *res;

    69

    70

      /* We first assume that it is a constant... */

    71

      res = search_constant_type.get_type(il_operand);

    72

      if (res != NULL) return res;

    73

    74

      /* Nope, now we assume it is a variable, and determine its type... */

    75

      res = search_varfb_instance_type.get_type(il_operand);

    76

      if (NULL != res) return res;

    77

    78

      /* not found */

    79

      return NULL;

    80

    }

    81

};

    82

    83

    84

    85

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

    86

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

    87

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

    88

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

    89

    90

    91

/* A new class to ouput the il default variable to c++ code

    92

 * We use this class, inheriting from symbol_c, so it may be used

    93

 * as any other symbol_c object in the intermediate parse tree,

    94

 * more specifically, so it can be used as any other il operand.

    95

 * This makes the rest of the code much easier...

    96

 *

    97

 * Nevertheless, the basic visitor class visitor_c does not know

    98

 * how to visit this new il_default_variable_c class, so we have

    99

 * to extend that too.

   100

 * In reality extending the basic symbols doesn't quite work out

   101

 * as cleanly as desired (we need to use dynamic_cast in the

   102

 * accept method of the il_default_variable_c), but it is cleaner

   103

 * than the alternative...

   104

 */

   105

class il_default_variable_c;

   106

   107

/* This visitor class is not really required, we could place the

   108

 * visit() method directly in genertae_cc_il_c, but doing it in

   109

 * a seperate class makes the architecture more evident...

   110

 */

   111

class il_default_variable_visitor_c {

   112

  public:

   113

    virtual void *visit(il_default_variable_c *symbol) = 0;

   114

   115

    virtual ~il_default_variable_visitor_c(void) {return;}

   116

};

   117

   118

   119

/* A class to print out to the resulting C++ code

   120

 * the IL default variable name.

   121

 *

   122

 * It includes a reference to its name,

   123

 * and the data type of the data currently stored

   124

 * in this C++ variable... This is required because the

   125

 * C++ variable is a union, and we must know which member

   126

 * of the union top reference!!

   127

 *

   128

 * Note that we also need to keep track of the data type of

   129

 * the value currently being stored in the default variable.

   130

 * This is required so we can process parenthesis,

   131

 *

   132

 * e.g. :

   133

 *         LD var1

   134

 *         AND (

   135

 *         LD var2

   136

 *         OR var3

   137

 *         )

   138

 *

   139

 * Note that we only execute the 'AND (' operation when we come across

   140

 * the ')', i.e. once we have evaluated the result of the

   141

 * instructions inside the parenthesis.

   142

 * When we do execute the 'AND (' operation, we need to know the data type

   143

 * of the operand, which in this case is the result of the evaluation of the

   144

 * instruction list inside the parenthesis. We can only know this if we

   145

 * keep track of the data type currently stored in the default variable!

   146

 *

   147

 * We use the current_type inside the generate_c_il::default_variable_name variable

   148

 * to track this!

   149

 */

   150

class il_default_variable_c: public symbol_c {

   151

  public:

   152

    symbol_c *var_name;  /* in principle, this should point to an indentifier_c */

   153

    symbol_c *current_type;

   154

   155

  public:

   156

    il_default_variable_c(const char *var_name_str, symbol_c *current_type);

   157

    virtual void *accept(visitor_c &visitor);

   158

};

   159

   160

   161

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

   162

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

   163

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

   164

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

   165

   166

   167

   168

class generate_c_il_c: public generate_c_typedecl_c, il_default_variable_visitor_c {

   169

   170

  private:

   171

    /* When compiling il code, it becomes necessary to determine the

   172

     * data type of il operands. To do this, we must first find the

   173

     * il operand's declaration, within the scope of the function block

   174

     * or function currently being processed.

   175

     * The following object does just that...

   176

     * This object instance will then later be called while the

   177

     * remaining il code is being handled.

   178

     */

   179

    //search_il_operand_type_c *search_il_operand_type;

   180

    search_expression_type_c *search_expression_type;

   181

   182

    /* The initial value that should be given to the IL default variable

   183

     * imediately after a parenthesis is opened.

   184

     * This variable is only used to pass data from the

   185

     * il_expression_c visitor to the simple_instr_list_c visitor.

   186

     *

   187

     * e.g.:

   188

     *         LD var1

   189

     *         AND ( var2

   190

     *         OR var3

   191

     *         )

   192

     *

   193

     * In the above code sample, the line 'AND ( var2' constitutes

   194

     * an il_expression_c, where var2 should be loaded into the

   195

     * il default variable before continuing with the expression

   196

     * inside the parenthesis.

   197

     * Unfortunately, only the simple_instr_list_c may do the

   198

     * initial laoding of the var2 bariable following the parenthesis,

   199

     * so the il_expression_c visitor will have to pass 'var2' as a

   200

     * parameter to the simple_instr_list_c visitor.

   201

     * Ergo, the existance of the following parameter...!

   202

     */

   203

    symbol_c *il_default_variable_init_value;

   204

   205

    /* Operand to the IL operation currently being processed... */

   206

    /* These variables are used to pass data from the

   207

     * il_simple_operation_c and il_expression_c visitors

   208

     * to the il operator visitors (i.e. LD_operator_c,

   209

     * LDN_operator_c, ST_operator_c, STN_operator_c, ...)

   210

     */

   211

    symbol_c *current_operand;

   212

    symbol_c *current_operand_type;

   213

   214

    /* Label to which the current IL jump operation should jump to... */

   215

    /* This variable is used to pass data from the

   216

     * il_jump_operation_c visitor

   217

     * to the il jump operator visitors (i.e. JMP_operator_c,

   218

     * JMPC_operator_c, JMPCN_operator_c, ...)

   219

     */

   220

    symbol_c *jump_label;

   221

   222

    /* The result of the comparison IL operations (GT, EQ, LT, ...)

   223

     * is a boolean variable.

   224

     * This class keeps track of the current data type stored in the

   225

     * il default variable. This is usually done by keeping a reference

   226

     * to the data type of the last operand. Nevertheless, in the case of

   227

     * the comparison IL operators, the data type of the result (a boolean)

   228

     * is not the data type of the operand. We therefore need an object

   229

     * of the boolean data type to keep as a reference of the current

   230

     * data type.

   231

     * The following object is it...

   232

     */

   233

    bool_type_name_c bool_type;

   234

   235

    /* the data type of the IL default variable... */

   236

    #define IL_DEFVAR_T VAR_LEADER "IL_DEFVAR_T"

   237

    /* The name of the IL default variable... */

   238

    #define IL_DEFVAR   VAR_LEADER "IL_DEFVAR"

   239

    /* The name of the variable used to pass the result of a

   240

     * parenthesised instruction list to the immediately preceding

   241

     * scope ...

   242

     */

   243

    #define IL_DEFVAR_BACK   VAR_LEADER "IL_DEFVAR_BACK"

   244

    il_default_variable_c default_variable_name;

   245

    il_default_variable_c default_variable_back_name;

   246

   247

    /* Some function calls in the body of functions or function blocks

   248

     * may leave some parameters to their default values, and

   249

     * ignore some output parameters of the function being called.

   250

     * Our conversion of ST functions to C++ does not contemplate that,

   251

     * i.e. each called function must get all it's input and output

   252

     * parameters set correctly.

   253

     * For input parameters we merely need to call the function with

   254

     * the apropriate default value, but for output parameters

   255

     * we must create temporary variables to hold the output value.

   256

     *

   257

     * We declare all the temporary output variables at the begining of

   258

     * the body of each function or function block, and use them as

   259

     * in function calls later on as they become necessary...

   260

     * Note that we cannot create these variables just before a function

   261

     * call, as the function call itself may be integrated within an

   262

     * expression, or another function call!

   263

     *

   264

     * The variables are declared in the exact same order in which they

   265

     * will be used later on during the function calls, which allows us

   266

     * to simply re-create the name that was used for the temporary variable

   267

     * instead of keeping it in some list.

   268

     * The names are recreated by the temp_var_name_factory, after reset()

   269

     * has been called!

   270

     *

   271

     * This function will genertae code similar to...

   272

     *

   273

     *     INT __TMP_0 = 23;

   274

     *     REAL __TMP_1 = 45.5;

   275

     *     ...

   276

     */

   277

    temp_var_name_c temp_var_name_factory;

   278

   279

    /* When calling a function block, we must first find it's type,

   280

     * by searching through the declarations of the variables currently

   281

     * in scope.

   282

     * This class does just that...

   283

     * A new class is instantiated whenever we begin generating the code

   284

     * for a function block type declaration, or a program declaration.

   285

     * This object instance will then later be called while the

   286

     * function block's or the program's body is being handled.

   287

     *

   288

     * Note that functions cannot contain calls to function blocks,

   289

     * so we do not create an object instance when handling

   290

     * a function declaration.

   291

     */

   292

    search_fb_instance_decl_c *search_fb_instance_decl;

   293

   297

   298

  public:

   299

    generate_c_il_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL)

   300

    : generate_c_typedecl_c(s4o_ptr),

   301

      default_variable_name(IL_DEFVAR, NULL),

   302

      default_variable_back_name(IL_DEFVAR_BACK, NULL)

   303

    {

   304

      //search_il_operand_type  = new search_il_operand_type_c(scope);

   305

      search_expression_type = new search_expression_type_c(scope);

   306

      search_fb_instance_decl = new search_fb_instance_decl_c(scope);

   308

      current_operand = NULL;

   309

      current_operand_type = NULL;

   310

      il_default_variable_init_value = NULL;

   311

      this->set_variable_prefix(variable_prefix);

   312

    }

   313

   314

    virtual ~generate_c_il_c(void) {

   315

      delete search_fb_instance_decl;

   316

      //delete search_il_operand_type;

   317

      delete search_expression_type;

   319

    }

   320

   321

    void generate(instruction_list_c *il) {

   322

      generate_c_tempvardecl_c generate_c_tempvardecl(&s4o);

   323

      generate_c_tempvardecl.generate(il, &temp_var_name_factory);

   324

      il->accept(*this);

   325

    }

   326

   327

    /* Declare the backup to the default variable, that will store the result

   328

     * of the IL operations executed inside a parenthesis...

   329

     */

   330

    void declare_backup_variable(void) {

   331

      s4o.print(s4o.indent_spaces);

   332

      s4o.print(IL_DEFVAR_T);

   333

      s4o.print(" ");

   334

      print_backup_variable();

   335

      s4o.print(";\n");

   336

    }

   337

   338

    void print_backup_variable(void) {

   339

      this->default_variable_back_name.accept(*this);

   340

    }

   341

   342

  private:

   343

    /* A helper function... */

   344

    /*

   345

    bool is_bool_type(symbol_c *type_symbol) {

   346

      return (NULL != dynamic_cast<bool_type_name_c *>(type_symbol));

   347

    }

   348

    */

   349

   350

    /* A helper function... */

   351

    void *XXX_operator(symbol_c *lo, const char *op, symbol_c *ro) {

   352

      if ((NULL == lo) || (NULL == ro)) ERROR;

   353

      if (NULL == op) ERROR;

   354

   355

      lo->accept(*this);

   356

      s4o.print(op);

   357

      ro->accept(*this);

   358

      return NULL;

   359

    }

   360

   361

    /* A helper function... */

   362

    void *XXX_function(const char *func, symbol_c *lo, symbol_c *ro) {

   363

      if ((NULL == lo) || (NULL == ro)) ERROR;

   364

      if (NULL == func) ERROR;

   365

   366

      lo->accept(*this);

   367

      s4o.print(" = ");

   368

      s4o.print(func);

   369

      s4o.print("(");

   370

      lo->accept(*this);

   371

      s4o.print(", ");

   372

      ro->accept(*this);

   373

      s4o.print(")");

   374

      return NULL;

   375

    }

   376

   377

    /* A helper function... */

   378

    void *XXX_CAL_operator(const char *param_name, symbol_c *fb_name) {

   379

      if (NULL == fb_name) ERROR;

   380

      symbolic_variable_c *sv = dynamic_cast<symbolic_variable_c *>(fb_name);

   381

      if (NULL == sv) ERROR;

   382

      identifier_c *id = dynamic_cast<identifier_c *>(sv->var_name);

   383

      if (NULL == id) ERROR;

   384

   385

      identifier_c param(param_name);

   386

   387

      //SYM_REF3(il_param_assignment_c, il_assign_operator, il_operand, simple_instr_list)

   388

      il_param_assignment_c il_param_assignment(&param, &this->default_variable_name, NULL);

   389

      // SYM_LIST(il_param_list_c)

   390

      il_param_list_c il_param_list;

   391

      il_param_list.add_element(&il_param_assignment);

   392

      CAL_operator_c CAL_operator;

   393

      // SYM_REF4(il_fb_call_c, il_call_operator, fb_name, il_operand_list, il_param_list)

   394

      il_fb_call_c il_fb_call(&CAL_operator, id, NULL, &il_param_list);

   395

   396

      il_fb_call.accept(*this);

   397

      return NULL;

   398

    }

   399

   400

    /* A helper function... */

   401

    void *CMP_operator(symbol_c *o, const char *operation) {

   402

      if (NULL == o) ERROR;

   403

      if (NULL == this->default_variable_name.current_type) ERROR;

   404

   405

      symbol_c *backup = this->default_variable_name.current_type;

   406

      this->default_variable_name.current_type = &(this->bool_type);

   407

      this->default_variable_name.accept(*this);

   408

      this->default_variable_name.current_type = backup;

   409

   410

      s4o.print(" = ");

   411

      s4o.print(operation);

   412

      this->default_variable_name.current_type->accept(*this);

   413

      s4o.print("(2, ");

   414

      this->default_variable_name.accept(*this);

   415

      s4o.print(", ");

   416

      o->accept(*this);

   417

      s4o.print(")");

   418

   419

      /* the data type resulting from this operation... */

   420

      this->default_variable_name.current_type = &(this->bool_type);

   421

      return NULL;

   422

    }

   423

   424

   425

    /* A helper function... */

   426

    void C_modifier(void) {

   427

      if (search_expression_type->is_bool_type(default_variable_name.current_type)) {

   428

        s4o.print("if (");

   429

        this->default_variable_name.accept(*this);

   430

        s4o.print(") ");

   431

      }

   432

      else {ERROR;}

   433

    }

   434

   435

    /* A helper function... */

   436

    void CN_modifier(void) {

   437

      if (search_expression_type->is_bool_type(default_variable_name.current_type)) {

   438

        s4o.print("if (!");

   439

        this->default_variable_name.accept(*this);

   440

        s4o.print(") ");

   441

      }

   442

      else {ERROR;}

   443

    }

   444

   445

   446

public:

   447

void *visit(il_default_variable_c *symbol) {

   448

  //s4o.print("il_default_variable_c VISITOR!!\n");

   449

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

   450

  if (NULL != symbol->current_type) {

   451

    s4o.print(".");

   452

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

   453

    s4o.print("var");

   454

  }

   455

  return NULL;

   456

}

   457

   458

   459

private:

   460

   461

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

   462

/* B.1.4.1   Directly Represented Variables */

   463

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

   464

// direct_variable: direct_variable_token   {$$ = new direct_variable_c($1);};

   465

void *visit(direct_variable_c *symbol) {

   466

  TRACE("direct_variable_c");

   467

  /* Do not use print_token() as it will change everything into uppercase */

   468

  if (strlen(symbol->value) == 0) ERROR;

   469

  s4o.print("*(");

   470

  this->print_variable_prefix();

   471

  s4o.printlocation(symbol->value + 1);

   472

  s4o.print(")");

   473

  return NULL;

   474

}

   475

   476

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

   477

/* B.2 - Language IL (Instruction List) */

   478

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

   479

   480

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

   481

/* B 2.1 Instructions and Operands */

   482

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

   483

   484

/* please see the comment before the RET_operator_c visitor for details... */

   485

#define END_LABEL VAR_LEADER "end"

   486

   487

/*| instruction_list il_instruction */

   488

void *visit(instruction_list_c *symbol) {

   489

   490

  /* Declare the backup to the default variable, that will store the result

   491

   * of the IL operations executed inside a parenthesis...

   492

   */

   493

  declare_backup_variable();

   494

   495

  /* Declare the default variable, that will store the result of the IL operations... */

   496

  s4o.print(s4o.indent_spaces);

   497

  s4o.print(IL_DEFVAR_T);

   498

  s4o.print(" ");

   499

  this->default_variable_name.accept(*this);

   500

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

   501

   502

  print_list(symbol, s4o.indent_spaces, ";\n" + s4o.indent_spaces, ";\n");

   503

   504

  /* write the label marking the end of the code block */

   505

  /* please see the comment before the RET_operator_c visitor for details... */

   506

  s4o.print("\n");

   507

  s4o.print(s4o.indent_spaces);

   508

  s4o.print(END_LABEL);

   509

  s4o.print(":\n");

   510

  s4o.indent_right();

   511

  /* since every label must be followed by at least one statement, and

   512

   * only the functions will introduce the return statement after this label,

   513

   * function blocks written in IL would result in invalid C++ code.

   514

   * To work around this we introduce the equivalent of a 'nop' operation

   515

   * to humour the compiler...

   516

   */

   517

  s4o.print(s4o.indent_spaces);

   518

  s4o.print("/* to humour the compiler, we insert a nop */\n");

   519

  s4o.print(s4o.indent_spaces);

   520

  this->default_variable_name.accept(*this);

   521

  s4o.print(" = ");

   522

  this->default_variable_name.accept(*this);

   523

  s4o.print(";\n");

   524

  s4o.indent_left();

   525

   526

  return NULL;

   527

}

   528