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

    39

    40

    41

class generate_cc_st_c: public generate_cc_typedecl_c {

    42

    43

  private:

    44

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

    45

     * by searching through the declarations of the variables currently

    46

     * in scope.

    47

     * This class does just that...

    48

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

    49

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

    50

     * This object instance will then later be called while the

    51

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

    52

     *

    53

     * Note that functions cannot contain calls to function blocks,

    54

     * so we do not create an object instance when handling

    55

     * a function declaration.

    56

     */

    57

    search_fb_instance_decl_c *search_fb_instance_decl;

    58

    68

    69

  public:

    70

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

    71

    : generate_cc_typedecl_c(s4o_ptr) {

    72

      search_fb_instance_decl = new search_fb_instance_decl_c(scope);

    74

      this->set_variable_prefix(variable_prefix);

    75

    }

    76

    77

    virtual ~generate_cc_st_c(void) {

    78

      delete search_fb_instance_decl;

    80

    }

    81

    82

    83

  private:

    84

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

    85

     * may leave some parameters to their default values, and

    86

     * ignore some output parameters of the function being called.

    87

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

    88

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

    89

     * parameters set correctly.

    90

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

    91

     * the apropriate default value, but for output parameters

    92

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

    93

     *

    94

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

    95

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

    96

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

    97

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

    98

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

    99

     * expression, or another function call!

   100

     *

   101

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

   102

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

   103

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

   104

     * instead of keeping it in some list.

   105

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

   106

     * has been called!

   107

     *

   108

     * This function will genertae code similar to...

   109

     *

   110

     *     INT __TMP_0 = 23;

   111

     *     REAL __TMP_1 = 45.5;

   112

     *     ...

   113

     */

   114

    temp_var_name_c temp_var_name_factory;

   115

   116

  public:

   117

    void generate(statement_list_c *stl) {

   118

      generate_cc_tempvardecl_c generate_cc_tempvardecl(&s4o);

   119

      generate_cc_tempvardecl.generate(stl, &temp_var_name_factory);

   120

      stl->accept(*this);

   121

    }

   122

   123

  private:

   125

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

   126

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

   127

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

   128

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

   129

/* B 3.1 - Expressions */

   130

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

   259

void *visit(div_expression_c *symbol) {return print_binary_expression(symbol->l_exp, symbol->r_exp, " / ");}

   260

void *visit(mod_expression_c *symbol) {

   261

  s4o.print("((");

   262

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

   263

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

   264

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

   265

  s4o.print(")");

   266

  return NULL;

   267

}

   268

   269

/* TODO: power expression... */

   270

void *visit(power_expression_c *symbol) {ERROR; return print_binary_expression(symbol->l_exp, symbol->r_exp, " ** ");}

   271

void *visit(neg_expression_c *symbol) {return print_unary_expression(symbol->exp, " -");}

   272

void *visit(not_expression_c *symbol) {return print_unary_expression(symbol->exp, "!");}

   273

   274

void *visit(function_invocation_c *symbol) {

   275

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

   276

   277

  if (f_decl == function_symtable.end_value())

   278

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

   279

    ERROR;

   280

   281

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

   282

  s4o.print("(");

   283

   284

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

   285

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

   286

   */

   287

   288

  function_param_iterator_c fp_iterator(f_decl);

   289

  identifier_c *param_name;

   290

  function_call_param_iterator_c function_call_param_iterator(symbol);

   291

  for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {

   292

    if (i != 1)

   293

      s4o.print(", ");

   294

   295

    symbol_c *param_type = fp_iterator.param_type();

   296

    if (param_type == NULL) ERROR;

   297

   298

    function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();

   299

   300

    /* Get the value from a foo(<param_name> = <param_value>) style call */

   301

    symbol_c *param_value = function_call_param_iterator.search(param_name);

   302

   303

    /* Get the value from a foo(<param_value>) style call */

   304

    if (param_value == NULL)

   305

      param_value = function_call_param_iterator.next();

   306

   307

    switch (param_direction) {

   308

      case function_param_iterator_c::direction_in:

   309

        if (param_value == NULL) {

   310

          /* No value given for parameter, so we must use the default... */

   311

          /* First check whether default value specified in function declaration...*/

   312

          param_value = fp_iterator.default_value();

   313

        }

   314

        if (param_value == NULL) {

   315

          /* If not, get the default value of this variable's type */

   316

          param_value = (symbol_c *)param_type->accept(*type_initial_value_c::instance());

   317

        }

   318

        if (param_value == NULL) ERROR;

   319

        param_value->accept(*this);

   320

	break;

   321

      case function_param_iterator_c::direction_out:

   322

      case function_param_iterator_c::direction_inout:

   323

        if (param_value == NULL) {

   324

	  /* no parameter value given, so we pass a previously declared temporary variable. */

   325

          std::string *temp_var_name = temp_var_name_factory.new_name();

   326

          s4o.print(*temp_var_name);

   327

          delete temp_var_name;

   328

	} else {

   329

          param_value->accept(*this);

   330

	}

   331

	break;

   332

      case function_param_iterator_c::direction_extref:

   333

        /* TODO! */

   334

        ERROR;

   335

        break;

   336

    } /* switch */

   337

  } /* for(...) */

   338

   339

  // symbol->parameter_assignment->accept(*this);

   340

  s4o.print(")");

   341

  return NULL;

   342

}

   343

   344

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

   345

/* B 3.2 Statements */

   346

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

   347

void *visit(statement_list_c *symbol) {

   348

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

   349

}

   350

   351

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

   352

/* B 3.2.1 Assignment Statements */

   353

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

   354

void *visit(assignment_statement_c *symbol) {

   355

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

   356

  s4o.print(" = ");

   357

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

   358

  return NULL;

   359

}

   360

   361

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

   362

/* B 3.2.2 Subprogram Control Statements */

   363

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

   364

   365

/* fb_name '(' [param_assignment_list] ')' */

   366

/* param_assignment_list -> may be NULL ! */

   367

//SYM_REF2(fb_invocation_c, fb_name, param_assignment_list)

   368

void *visit(fb_invocation_c *symbol) {

   369

  TRACE("fb_invocation_c");

   370

  /* first figure out what is the name of the function block type of the function block being called... */

   371

  symbol_c *function_block_type_name = this->search_fb_instance_decl->get_type_name(symbol->fb_name);

   372

    /* should never occur. The function block instance MUST have been declared... */

   373

  if (function_block_type_name == NULL) ERROR;

   374

   375

  /* Now find the declaration of the function block type being called... */

   376

  function_block_declaration_c *fb_decl = function_block_type_symtable.find_value(function_block_type_name);

   377

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

   378

  if (fb_decl == function_block_type_symtable.end_value()) ERROR;

   379

   380

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

   381

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

   382

   */

   383

  function_param_iterator_c fp_iterator(fb_decl);

   384

  identifier_c *param_name;

   385

  function_call_param_iterator_c function_call_param_iterator(symbol);

   386

  for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {

   387

    function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();

   388

   389

    /* Get the value from a foo(<param_name> = <param_value>) style call */

   390

    symbol_c *param_value = function_call_param_iterator.search(param_name);

   391

   392

    /* Get the value from a foo(<param_value>) style call */

   393

    if (param_value == NULL)

   394

      param_value = function_call_param_iterator.next();

   395

   396

    /* now output the value assignment */

   397

    if (param_value != NULL)

   398

      if ((param_direction == function_param_iterator_c::direction_in) ||

   399

          (param_direction == function_param_iterator_c::direction_inout)) {

   400

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

   401

        s4o.print(".");

   402

        param_name->accept(*this);

   403

        s4o.print(" = ");

   404

        param_value->accept(*this);

   405

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

   406

      }

   407

  } /* for(...) */

   408

   409

  /* now call the function... */

   410

  function_block_type_name->accept(*this);

   411

  s4o.print(FB_FUNCTION_SUFFIX);

   412

  s4o.print("(&");

   413

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

   414

  s4o.print(")");

   415

   416

  /* loop through each function parameter, find the variable to which

   417

   * we should atribute the value of all output or inoutput parameters.

   418

   */

   419

  fp_iterator.reset();

   420

  function_call_param_iterator.reset();

   421

  for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {

   422

    function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();

   423

   424

    /* Get the value from a foo(<param_name> = <param_value>) style call */

   425

    symbol_c *param_value = function_call_param_iterator.search(param_name);

   426

   427

    /* Get the value from a foo(<param_value>) style call */

   428

    if (param_value == NULL)

   429

      param_value = function_call_param_iterator.next();

   430

   431

    /* now output the value assignment */

   432

    if (param_value != NULL)

   433

      if ((param_direction == function_param_iterator_c::direction_out) ||

   434

          (param_direction == function_param_iterator_c::direction_inout)) {

   435

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

   436

        param_value->accept(*this);

   437

        s4o.print(" = ");

   438

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

   439

        s4o.print(".");

   440

        param_name->accept(*this);

   441

      }

   442

  } /* for(...) */

   443

   444

  return NULL;

   445

}

   446

   447

   448

   449

   450

/* helper symbol for fb_invocation */

   451

/* param_assignment_list ',' param_assignment */

   452

void *visit(param_assignment_list_c *symbol) {

   453

  TRACE("param_assignment_list_c");

   454

  /* this should never be called... */

   455

  ERROR;

   456

  return NULL;

   457

//  return print_list(symbol, "", ", ");

   458

}

   459

   460

   461

void *visit(input_variable_param_assignment_c *symbol) {

   462

  TRACE("input_variable_param_assignment_c");

   463

  /* this should never be called... */

   464

  ERROR;

   465

  return NULL;

   466

/*

   467

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

   468

  s4o.print(" = ");

   469

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

   470

  return NULL;

   471

*/

   472

}

   473

   474

void *visit(output_variable_param_assignment_c *symbol) {

   475

  TRACE("output_variable_param_assignment_c");

   476

  /* this should never be called... */

   477

  ERROR;

   478

  return NULL;

   479

/*

   480

  s4o.print(s4o.indent_spaces);

   481

  if (symbol->not_param != NULL)

   482

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

   483

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

   484

  s4o.print(" => ");

   485

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

   486

  return NULL;

   487

*/

   488

}

   489

   490

// TODO: the NOT symbol in function (block) calls...

   491

void *visit(not_paramassign_c *symbol) {

   492

  TRACE("not_paramassign_c");

   493

  /* this should never be called... */

   494

  ERROR;

   495

  return NULL;

   496

/*

   497

  s4o.print("NOT ");

   498

  return NULL;

   499

*/

   500

}

   501

   502

   503

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

   504

/* B 3.2.3 Selection Statements */

   505

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

   506

void *visit(if_statement_c *symbol) {

   507

  s4o.print("if (");

   508

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

   509

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

   510

  s4o.indent_right();

   511

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

   512

  s4o.indent_left();

   513

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

   514

   515

  if (symbol->else_statement_list != NULL) {

   516

    s4o.print(s4o.indent_spaces); s4o.print("} else {\n");

   517

    s4o.indent_right();

   518

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

   519

    s4o.indent_left();