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 st statements (i.e. ST 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

class generate_c_st_c: public generate_c_typedecl_c {

    42

    43

  public:

    44

    typedef enum {

    45

      expression_vg,

    46

      assignment_vg,

    47

      fparam_output_vg

    48

    } variablegeneration_t;

    49

    50

  private:

    51

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

    52

     * by searching through the declarations of the variables currently

    53

     * in scope.

    54

     * This class does just that...

    55

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

    56

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

    57

     * This object instance will then later be called while the

    58

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

    59

     *

    60

     * Note that functions cannot contain calls to function blocks,

    61

     * so we do not create an object instance when handling

    62

     * a function declaration.

    63

     */

    64

    search_fb_instance_decl_c *search_fb_instance_decl;

    65

    66

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

    67

     * data type of st expressions. To do this, we must first find the

    68

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

    69

     * or function currently being processed.

    70

     * The following object does just that...

    71

     * This object instance will then later be called while the

    72

     * remaining st code is being handled.

    73

     */

    74

    search_expression_type_c *search_expression_type;

    75

    76

    search_varfb_instance_type_c *search_varfb_instance_type;

    77

    78

    search_base_type_c search_base_type;

    79

    80

    symbol_c* current_array_type;

    81

    82

    int fcall_number;

    83

    symbol_c *fbname;

    84

    85

    variablegeneration_t wanted_variablegeneration;

    86

    87

  public:

    88

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

    89

    : generate_c_typedecl_c(s4o_ptr) {

    90

      search_fb_instance_decl = new search_fb_instance_decl_c(scope);

    91

      search_expression_type = new search_expression_type_c(scope);

    92

      search_varfb_instance_type = new search_varfb_instance_type_c(scope);

    93

      this->set_variable_prefix(variable_prefix);

    94

      current_array_type = NULL;

    95

      fcall_number = 0;

    96

      fbname = name;

    97

      wanted_variablegeneration = expression_vg;

    98

    }

    99

   100

    virtual ~generate_c_st_c(void) {

   101

      delete search_fb_instance_decl;

   102

      delete search_expression_type;

   103

      delete search_varfb_instance_type;

   104

    }

   105

   106

   107

  public:

   108

    void generate(statement_list_c *stl) {

   109

      stl->accept(*this);

   110

    }

   111

   112

  private:

   113

   114

   115

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

   116

/* B 1.4 - Variables */

   117

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

   118

void *visit(symbolic_variable_c *symbol) {

   119

  unsigned int vartype = search_varfb_instance_type->get_vartype(symbol);

   120

  if (this->is_variable_prefix_null()) {

   121

    if (wanted_variablegeneration == fparam_output_vg) {

   123

    	s4o.print(GET_EXTERNAL);

   128

      s4o.print(")");

   129

    }

   130

    else {

   131

      if (vartype == search_var_instance_decl_c::external_vt) {

   132

        s4o.print(GET_EXTERNAL);

   133

        s4o.print("(");

   135

        s4o.print(")");

   136

      }

   137

      else

   138

    	generate_c_base_c::visit(symbol);

   139

    }

   140

  }

   141

  else {

   142

    switch (wanted_variablegeneration) {

   143

      case expression_vg:

   145

    	  s4o.print(GET_EXTERNAL);

   152

        s4o.print(")");

   153

		break;

   154

      case fparam_output_vg:

   156

          s4o.print(GET_EXTERNAL_BY_REF);

   163

        s4o.print(")");

   164

        break;

   165

      default:

   167

        break;

   168

	}

   169

  }

   170

  return NULL;

   171

}

   172

   173

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

   174

/* B.1.4.1   Directly Represented Variables */

   175

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

   176

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

   177

void *visit(direct_variable_c *symbol) {

   178

  TRACE("direct_variable_c");

   179

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

   180

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

   181

  if (this->is_variable_prefix_null()) {

   182

    if (wanted_variablegeneration != fparam_output_vg)

   183

	  s4o.print("*(");

   184

  }

   185

  else {

   186

    switch (wanted_variablegeneration) {

   187

      case expression_vg:

   188

  	    s4o.print(GET_LOCATED);

   189

  	    s4o.print("(");

   190

  	    break;

   191

      case fparam_output_vg:

   192

        s4o.print(GET_LOCATED_BY_REF);

   193

        s4o.print("(");

   194

        break;

   195

      default:

   196

        break;

   197

    }

   198

  }

   199

  this->print_variable_prefix();

   200

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

   201

  if ((this->is_variable_prefix_null() && wanted_variablegeneration != fparam_output_vg) ||

   202

	  wanted_variablegeneration != assignment_vg)

   203

    s4o.print(")");

   204

  return NULL;

   205

}

   206

   207

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

   208

/* B.1.4.2   Multi-element Variables */

   209

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

   210

   272

/*  subscripted_variable '[' subscript_list ']' */

   273

//SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   274

void *visit(array_variable_c *symbol) {

   275

  current_array_type = search_varfb_instance_type->get_type(symbol->subscripted_variable, false);

   276

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

   277

  if (current_array_type != NULL) {

   278

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

   279

    current_array_type = NULL;

   280

  }

   281

  return NULL;

   282

}

   283

   284

/* subscript_list ',' subscript */

   285

void *visit(subscript_list_c *symbol) {

   286

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

   287

    s4o.print("[__");

   288

    current_array_type->accept(*this);

   289

    s4o.print("_TRANSIDX");

   290

    print_integer(i);

   291

    s4o.print("(");

   292

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

   293

    s4o.print(")]");

   294

  }

   295

  return NULL;

   296

}

   297

   298

   299

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

   300

/* B.3 - Language ST (Structured Text) */

   301

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

   302

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

   303

/* B 3.1 - Expressions */

   304

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

   305

void *visit(or_expression_c *symbol) {

   306

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   307

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   308

  if (!search_expression_type->is_same_type(left_type, right_type))

   309

      ERROR;

   310

  if (search_expression_type->is_bool_type(left_type))

   311

    return print_binary_expression(symbol->l_exp, symbol->r_exp, " || ");

   312

  if (search_expression_type->is_binary_type(left_type))

   313

    return print_binary_expression(symbol->l_exp, symbol->r_exp, " | ");

   314

  ERROR;

   315

  return NULL;

   316

}

   317

   318

void *visit(xor_expression_c *symbol) {

   319

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   320

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   321

  if (!search_expression_type->is_same_type(left_type, right_type))

   322

      ERROR;

   323

  if (search_expression_type->is_bool_type(left_type)) {

   324

    s4o.print("(");

   325

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

   326

    s4o.print(" && !");

   327

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

   328

    s4o.print(") || (!");

   329

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

   330

    s4o.print(" && ");

   331

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

   332

    s4o.print(")");

   333

    return NULL;

   334

  }

   335

  if (search_expression_type->is_binary_type(left_type))

   336

    return print_binary_expression(symbol->l_exp, symbol->r_exp, " ^ ");

   337

  ERROR;

   338

  return NULL;

   339

}

   340

   341

void *visit(and_expression_c *symbol) {

   342

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   343

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   344

  if (!search_expression_type->is_same_type(left_type, right_type))

   345

      ERROR;

   346

  if (search_expression_type->is_bool_type(left_type))

   347

    return print_binary_expression(symbol->l_exp, symbol->r_exp, " && ");

   348

  if (search_expression_type->is_binary_type(left_type))

   349

    return print_binary_expression(symbol->l_exp, symbol->r_exp, " & ");

   350

  ERROR;

   351

  return NULL;

   352

}

   353

   354

void *visit(equ_expression_c *symbol) {

   355

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   356

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   357

  if (!search_expression_type->is_same_type(left_type, right_type))

   358

      ERROR;

   359

  if (search_expression_type->is_time_type(left_type) ||

   360

      search_expression_type->is_string_type(left_type))

   361

    return print_compare_function("__eq_", left_type, symbol->l_exp, symbol->r_exp);

   362

  return print_binary_expression(symbol->l_exp, symbol->r_exp, " == ");

   363

}

   364

   365

void *visit(notequ_expression_c *symbol) {

   366

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   367

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   368

  if (!search_expression_type->is_same_type(left_type, right_type))

   369

      ERROR;

   370

  if (search_expression_type->is_time_type(left_type) ||

   371

      search_expression_type->is_string_type(left_type))

   372

    return print_compare_function("__ne_", left_type, symbol->l_exp, symbol->r_exp);

   373

  return print_binary_expression(symbol->l_exp, symbol->r_exp, " != ");

   374

}

   375

   376

void *visit(lt_expression_c *symbol) {

   377

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   378

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   379

  if (!search_expression_type->is_same_type(left_type, right_type))

   380

      ERROR;

   381

  if (search_expression_type->is_time_type(left_type) ||

   382

      search_expression_type->is_string_type(left_type))

   383

    return print_compare_function("__lt_", left_type, symbol->l_exp, symbol->r_exp);

   384

  if (!search_base_type.type_is_enumerated(left_type))

   385

    return print_binary_expression(symbol->l_exp, symbol->r_exp, " < ");

   386

  ERROR;

   387

  return NULL;

   388

}

   389

   390

void *visit(gt_expression_c *symbol) {

   391

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   392

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   393

  if (!search_expression_type->is_same_type(left_type, right_type))

   394

      ERROR;

   395

  if (search_expression_type->is_time_type(left_type) ||

   396

      search_expression_type->is_string_type(left_type))

   397

    return print_compare_function("__gt_", left_type, symbol->l_exp, symbol->r_exp);

   398

  if (!search_base_type.type_is_enumerated(left_type))

   399

    return print_binary_expression(symbol->l_exp, symbol->r_exp, " > ");

   400

  ERROR;

   401

  return NULL;

   402

}

   403

   404

void *visit(le_expression_c *symbol) {

   405

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   406

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   407

  if (!search_expression_type->is_same_type(left_type, right_type))

   408

      ERROR;

   409

  if (search_expression_type->is_time_type(left_type) ||

   410

      search_expression_type->is_string_type(left_type))

   411

    return print_compare_function("__le_", left_type, symbol->l_exp, symbol->r_exp);

   412

  if (!search_base_type.type_is_enumerated(left_type))

   413

    return print_binary_expression(symbol->l_exp, symbol->r_exp, " <= ");

   414

  ERROR;

   415

  return NULL;

   416

}

   417

   418

void *visit(ge_expression_c *symbol) {

   419

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   420

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   421

  if (!search_expression_type->is_same_type(left_type, right_type))

   422

      ERROR;

   423

  if (search_expression_type->is_time_type(left_type) ||

   424

      search_expression_type->is_string_type(left_type))

   425

    return print_compare_function("__ge_", left_type, symbol->l_exp, symbol->r_exp);

   426

  if (!search_base_type.type_is_enumerated(left_type))

   427

    return print_binary_expression(symbol->l_exp, symbol->r_exp, " >= ");

   428

  ERROR;

   429

  return NULL;

   430

}

   431

   432

void *visit(add_expression_c *symbol) {

   433

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   434

	symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   435

	if ((typeid(*left_type) == typeid(time_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) ||

   436

      (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) ||

   437

      (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)))

   438

    return print_binary_function("__TIME_ADD", symbol->l_exp, symbol->r_exp);

   439

  if (!search_expression_type->is_same_type(left_type, right_type))

   440

      ERROR;

   441

  if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type))

   442

    return print_binary_expression(symbol->l_exp, symbol->r_exp, " + ");

   443

  ERROR;

   444

  return NULL;

   445

}

   446

   447

void *visit(sub_expression_c *symbol) {

   448

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   449

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   450

  if ((typeid(*left_type) == typeid(time_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) ||

   451

      (typeid(*left_type) == typeid(date_type_name_c) && typeid(*right_type) == typeid(date_type_name_c)) ||

   452

      (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) ||

   453

      (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(tod_type_name_c)) ||

   454

      (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) ||

   455

      (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(dt_type_name_c)))

   456

    return print_binary_function("__TIME_SUB", symbol->l_exp, symbol->r_exp);

   457

  if (!search_expression_type->is_same_type(left_type, right_type))

   458

      ERROR;

   459

  if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type))

   460

    return print_binary_expression(symbol->l_exp, symbol->r_exp, " - ");

   461

  ERROR;

   462

  return NULL;

   463

}

   464

   465

void *visit(mul_expression_c *symbol) {

   466

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   467

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   468

  if ((typeid(*left_type) == typeid(time_type_name_c) && search_expression_type->is_integer_type(right_type)) ||

   469

      (typeid(*left_type) == typeid(time_type_name_c) && search_expression_type->is_real_type(right_type)))

   470

    return print_binary_function("__TIME_MUL", symbol->l_exp, symbol->r_exp);

   471

  if (!search_expression_type->is_same_type(left_type, right_type))

   472

      ERROR;

   473

  if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type))

   474

    return print_binary_expression(symbol->l_exp, symbol->r_exp, " * ");

   475

  ERROR;

   476

  return NULL;

   477

}

   478

   479

void *visit(div_expression_c *symbol) {

   480

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   481

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   482

  if ((typeid(*left_type) == typeid(time_type_name_c) && search_expression_type->is_integer_type(right_type)) ||

   483

      (typeid(*left_type) == typeid(time_type_name_c) && search_expression_type->is_real_type(right_type)))

   484

    return print_binary_function("__TIME_DIV", symbol->l_exp, symbol->r_exp);

   485

  if (!search_expression_type->is_same_type(left_type, right_type))

   486

      ERROR;

   487

  if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type))

   488

    return print_binary_expression(symbol->l_exp, symbol->r_exp, " / ");

   489

  ERROR;

   490

  return NULL;

   491

}

   492

   493

void *visit(mod_expression_c *symbol) {

   494

  symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);

   495

  symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);

   496

  if (!search_expression_type->is_same_type(left_type, right_type))

   497

      ERROR;

   498

  if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type)) {

   499

    s4o.print("((");

   500

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

   501

    s4o.print(" == 0)?0:");

   502

    print_binary_expression(symbol->l_exp, symbol->r_exp, " % ");

   503

    s4o.print(")");

   504

    return NULL;

   505

  }

   506

  ERROR;

   507

  return NULL;

   508

}

   509

   510

/* TODO: power expression... */