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

class search_il_operand_type_c {

    57

    58

  private:

    59

    search_varfb_instance_type_c search_varfb_instance_type;

    60

    search_constant_type_c search_constant_type;

    61

    62

  public:

    63

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

    64

    65

  public:

    66

    symbol_c *get_type(symbol_c *il_operand) {

    67

      symbol_c *res;

    68

    69

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

    70

      res = search_constant_type.get_type(il_operand);

    71

      if (res != NULL) return res;

    72

    73

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

    74

      res = search_varfb_instance_type.get_type(il_operand);

    75

      if (NULL != res) return res;

    76

    77

      /* not found */

    78

      return NULL;

    79

    }

    80

};

    81

    82

    83

    84

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

    85

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

    86

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

    87

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

    88

    89

    90

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

    91

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

    92

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

    93

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

    94

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

    95

 *

    96

 * Nevertheless, the basic visitor class visitor_c does not know

    97

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

    98

 * to extend that too.

    99

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

   100

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

   101

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

   102

 * than the alternative...

   103

 */

   104

class il_default_variable_c;

   105

   106

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

   107

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

   108

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

   109

 */

   110

class il_default_variable_visitor_c {

   111

  public:

   112

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

   113

   114

    virtual ~il_default_variable_visitor_c(void) {return;}

   115

};

   116

   117

   118

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

   119

 * the IL default variable name.

   120

 *

   121

 * It includes a reference to its name,

   122

 * and the data type of the data currently stored

   123

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

   124

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

   125

 * of the union top reference!!

   126

 *

   127

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

   128

 * the value currently being stored in the default variable.

   129

 * This is required so we can process parenthesis,

   130

 *

   131

 * e.g. :

   132

 *         LD var1

   133

 *         AND (

   134

 *         LD var2

   135

 *         OR var3

   136

 *         )

   137

 *

   138

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

   139

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

   140

 * instructions inside the parenthesis.

   141

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

   142

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

   143

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

   144

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

   145

 *

   146

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

   147

 * to track this!

   148

 */

   149

class il_default_variable_c: public symbol_c {

   150

  public:

   151

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

   152

    symbol_c *current_type;

   153

   154

  public:

   155

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

   156

    virtual void *accept(visitor_c &visitor);

   157

};

   158

   159

   160

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

   161

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

   162

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

   163

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

   164

   165

   166

   167

class generate_cc_il_c: public generate_cc_typedecl_c, il_default_variable_visitor_c {

   168

   169

  private:

   170

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

   171

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

   172

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

   173

     * or function currently being processed.

   174

     * The following object does just that...

   175

     * This object instance will then later be called while the

   176

     * remaining il code is being handled.

   177

     */

   178

    search_il_operand_type_c *search_il_operand_type;

   179

   180

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

   181

     * imediately after a parenthesis is opened.

   182

     * This variable is only used to pass data from the

   183

     * il_expression_c visitor to the simple_instr_list_c visitor.

   184

     *

   185

     * e.g.:

   186

     *         LD var1

   187

     *         AND ( var2

   188

     *         OR var3

   189

     *         )

   190

     *

   191

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

   192

     * an il_expression_c, where var2 should be loaded into the

   193

     * il default variable before continuing with the expression

   194

     * inside the parenthesis.

   195

     * Unfortunately, only the simple_instr_list_c may do the

   196

     * initial laoding of the var2 bariable following the parenthesis,

   197

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

   198

     * parameter to the simple_instr_list_c visitor.

   199

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

   200

     */

   201

    symbol_c *il_default_variable_init_value;

   202

   203

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

   204

    /* These variables are used to pass data from the

   205

     * il_simple_operation_c and il_expression_c visitors

   206

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

   207

     * LDN_operator_c, ST_operator_c, STN_operator_c, ...)

   208

     */

   209

    symbol_c *current_operand;

   210

    symbol_c *current_operand_type;

   211

   212

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

   213

    /* This variable is used to pass data from the

   214

     * il_jump_operation_c visitor

   215

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

   216

     * JMPC_operator_c, JMPCN_operator_c, ...)

   217

     */

   218

    symbol_c *jump_label;

   219

   220

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

   221

     * is a boolean variable.

   222

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

   223

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

   224

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

   225

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

   226

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

   227

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

   228

     * data type.

   229

     * The following object is it...

   230

     */

   231

    bool_type_name_c bool_type;

   232

   233

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

   234

    #define IL_DEFVAR_T VAR_LEADER "IL_DEFVAR_T"

   235

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

   236

    #define IL_DEFVAR   VAR_LEADER "IL_DEFVAR"

   237

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

   238

     * parenthesised instruction list to the immediately preceding

   239

     * scope ...

   240

     */

   241

    #define IL_DEFVAR_BACK   VAR_LEADER "IL_DEFVAR_BACK"

   242

    il_default_variable_c default_variable_name;

   243

    il_default_variable_c default_variable_back_name;

   244

   245

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

   246

     * may leave some parameters to their default values, and

   247

     * ignore some output parameters of the function being called.

   248

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

   249

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

   250

     * parameters set correctly.

   251

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

   252

     * the apropriate default value, but for output parameters

   253

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

   254

     *

   255

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

   256

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

   257

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

   258

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

   259

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

   260

     * expression, or another function call!

   261

     *

   262

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

   263

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

   264

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

   265

     * instead of keeping it in some list.

   266

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

   267

     * has been called!

   268

     *

   269

     * This function will genertae code similar to...

   270

     *

   271

     *     INT __TMP_0 = 23;

   272

     *     REAL __TMP_1 = 45.5;

   273

     *     ...

   274

     */

   275

    temp_var_name_c temp_var_name_factory;

   276

   277

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

   278

     * by searching through the declarations of the variables currently

   279

     * in scope.

   280

     * This class does just that...

   281

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

   282

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

   283

     * This object instance will then later be called while the

   284

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

   285

     *

   286

     * Note that functions cannot contain calls to function blocks,

   287

     * so we do not create an object instance when handling

   288

     * a function declaration.

   289

     */

   290

    search_fb_instance_decl_c *search_fb_instance_decl;

   291

   292

   293

  public:

   294

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

   295

    : generate_cc_typedecl_c(s4o_ptr),

   296

      default_variable_name(IL_DEFVAR, NULL),

   297

      default_variable_back_name(IL_DEFVAR_BACK, NULL)

   298

    {

   299

      search_il_operand_type  = new search_il_operand_type_c(scope);

   300

      search_fb_instance_decl = new search_fb_instance_decl_c(scope);

   301

      current_operand = NULL;

   302

      current_operand_type = NULL;

   303

      il_default_variable_init_value = NULL;

   304

      this->set_variable_prefix(variable_prefix);

   305

    }

   306

   307

    virtual ~generate_cc_il_c(void) {

   308

      delete search_fb_instance_decl;

   309

      delete search_il_operand_type;

   310

    }

   311

   312

    void generate(instruction_list_c *il) {

   313

      generate_cc_tempvardecl_c generate_cc_tempvardecl(&s4o);

   314

      generate_cc_tempvardecl.generate(il, &temp_var_name_factory);

   315

      il->accept(*this);

   316

    }

   317

   318

  private:

   319

    /* A helper function... */

   320

    bool is_bool_type(symbol_c *type_symbol) {

   321

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

   322

    }

   323

   324

    /* A helper function... */

   325

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

   326

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

   327

      if (NULL == op) ERROR;

   328

   329

      lo->accept(*this);

   330

      s4o.print(op);

   331

      ro->accept(*this);

   332

      return NULL;

   333

    }

   334

   335

    /* A helper function... */

   336

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

   337

      if (NULL == fb_name) ERROR;

   338

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

   339

      if (NULL == sv) ERROR;

   340

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

   341

      if (NULL == id) ERROR;

   342

   343

      identifier_c param(param_name);

   344

   345

      //SYM_REF4(il_param_assignment_c, il_assign_operator, il_operand, simple_instr_list, unused)

   346

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

   347

      // SYM_LIST(il_param_list_c)

   348

      il_param_list_c il_param_list;

   349

      il_param_list.add_element(&il_param_assignment);

   350

      CAL_operator_c CAL_operator;

   351

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

   352

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

   353

   354

      il_fb_call.accept(*this);

   355

      return NULL;

   356

    }

   357

   358

    /* A helper function... */

   359

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

   360

      if (NULL == o) ERROR;

   361

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

   362

   363

      symbol_c *backup = this->default_variable_name.current_type;

   364

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

   365

      this->default_variable_name.accept(*this);

   366

      this->default_variable_name.current_type = backup;

   367

   368

      s4o.print(" = (");

   369

      this->default_variable_name.accept(*this);

   370

      s4o.print(operation);

   371

      o->accept(*this);

   372

      s4o.print(")");

   373

   374

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

   375

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

   376

      return NULL;

   377

    }

   378

   379

   380

    /* A helper function... */

   381

    void C_modifier(void) {

   382

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

   383

   384

      s4o.print("if (");

   385

      this->default_variable_name.accept(*this);

   386

      s4o.print(") ");

   387

    }

   388

   389

    /* A helper function... */

   390

    void CN_modifier(void) {

   391

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

   392

   393

      s4o.print("if (!");

   394

      this->default_variable_name.accept(*this);

   395

      s4o.print(") ");

   396

    }

   397

   398

   399

public:

   400

void *visit(il_default_variable_c *symbol) {

   401

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

   402

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

   403

  if (NULL != symbol->current_type) {

   404

    s4o.print(".");

   405

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

   406

    s4o.print("var");

   407

  }

   408

  return NULL;

   409

}

   410

   411

   412

private:

   413

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

   414

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

   415

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

   416

   417

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

   418

/* B 2.1 Instructions and Operands */

   419

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

   420

   421

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

   422

#define END_LABEL VAR_LEADER "end"

   423

   424

/*| instruction_list il_instruction */

   425

void *visit(instruction_list_c *symbol) {

   426

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

   427

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

   428

   */

   429

  s4o.print(s4o.indent_spaces);

   430

  s4o.print(IL_DEFVAR_T);

   431

  s4o.print(" ");

   432

  this->default_variable_back_name.accept(*this);

   433

  s4o.print(";\n");

   434

   435

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

   436

  s4o.print(s4o.indent_spaces);

   437

  s4o.print(IL_DEFVAR_T);

   438

  s4o.print(" ");

   439

  this->default_variable_name.accept(*this);

   440

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

   441

   442

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

   443

   444

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

   445

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

   446

  s4o.print("\n");

   447

  s4o.print(s4o.indent_spaces);

   448

  s4o.print(END_LABEL);

   449

  s4o.print(":\n");

   450

  s4o.indent_right();

   451

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

   452

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

   453

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

   454

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

   455

   * to humour the compiler...

   456

   */

   457

  s4o.print(s4o.indent_spaces);

   458

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

   459

  s4o.print(s4o.indent_spaces);

   460

  this->default_variable_name.accept(*this);

   461

  s4o.print(" = ");

   462

  this->default_variable_name.accept(*this);

   463

  s4o.print(";\n");

   464

  s4o.indent_left();

   465

   466

  return NULL;

   467

}

   468

   469

   470

/* | label ':' [il_incomplete_instruction] eol_list */

   471

// SYM_REF2(il_instruction_c, label, il_instruction)

   472

void *visit(il_instruction_c *symbol) {

   473

  if (NULL != symbol->label) {

   474

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

   475

    s4o.print(":\n");

   476

    s4o.print(s4o.indent_spaces);

   477

  }

   478

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

   479

  return NULL;

   480

}

   481

   482

/* | il_simple_operator [il_operand] */

   483

//SYM_REF2(il_simple_operation_c, il_simple_operator, il_operand)

   484

void *visit(il_simple_operation_c *symbol) {

   485

  this->current_operand = symbol->il_operand;

   486

  if (NULL == this->current_operand) {

   487

    this->current_operand_type = NULL;

   488

  } else {

   489

    this->current_operand_type = search_il_operand_type->get_type(this->current_operand);

   490

    if (NULL == this->current_operand_type) ERROR;

   491

  }

   492

   493

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

   494

   495

  this->current_operand = NULL;

   496

  this->current_operand_type = NULL;

   497

  return NULL;

   498

}

   499

   500

   501

/* | function_name [il_operand_list] */

   502

// SYM_REF2(il_function_call_c, function_name, il_operand_list)

   503

void *visit(il_function_call_c *symbol) {

   504

  function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name);

   505

   506

  if (f_decl == function_symtable.end_value())

   507

    /* should never occur. The function being called MUST be in the symtable... */

   508

    ERROR;

   509

   510

  /* determine the base data type returned by the function being called... */

   511

  search_base_type_c search_base_type;

   512

  symbol_c *return_data_type = (symbol_c *)f_decl->type_name->accept(search_base_type);

   513

  symbol_c *param_data_type = default_variable_name.current_type;

   514

  if (NULL == return_data_type) ERROR;

   515

   516

  default_variable_name.current_type = return_data_type;

   517

  this->default_variable_name.accept(*this);

   518

  default_variable_name.current_type = param_data_type;

   519

  s4o.print(" = ");

   520

   521

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

   522

  s4o.print("(");

   523

   524

  /* loop through each function parameter, find the value we should pass

   525

   * to it, and then output the c equivalent...

   526

   */

   527

   528

  function_param_iterator_c fp_iterator(f_decl);

   529

  identifier_c *param_name;

   530

  function_call_param_iterator_c function_call_param_iterator(symbol);