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

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

    58

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

    59

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

    60

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

    61

    62

    63

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

    64

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

    65

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

    66

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

    67

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

    68

 *

    69

 * Nevertheless, the basic visitor class visitor_c does not know

    70

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

    71

 * to extend that too.

    72

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

    73

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

    74

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

    75

 * than the alternative...

    76

 */

    77

class il_default_variable_c;

    78

    79

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

    80

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

    81

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

    82

 */

    83

class il_default_variable_visitor_c {

    84

  public:

    85

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

    86

    87

    virtual ~il_default_variable_visitor_c(void) {return;}

    88

};

    89

    90

    91

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

    92

 * the IL default variable name.

    93

 *

    94

 * It includes a reference to its name,

    95

 * and the data type of the data currently stored

    96

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

    97

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

    98

 * of the union top reference!!

    99

 *

   100

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

   101

 * the value currently being stored in the default variable.

   102

 * This is required so we can process parenthesis,

   103

 *

   104

 * e.g. :

   105

 *         LD var1

   106

 *         AND (

   107

 *         LD var2

   108

 *         OR var3

   109

 *         )

   110

 *

   111

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

   112

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

   113

 * instructions inside the parenthesis.

   114

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

   115

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

   116

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

   117

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

   118

 *

   119

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

   120

 * to track this!

   121

 */

   122

class il_default_variable_c: public symbol_c {

   123

  public:

   124

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

   125

    symbol_c *current_type;

   126

   127

  public:

   128

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

   129

    virtual void *accept(visitor_c &visitor);

   130

};

   131

   132

   133

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

   134

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

   135

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

   136

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

   137

   138

   139

   140

class generate_c_il_c: public generate_c_typedecl_c, il_default_variable_visitor_c {

   141

   142

  public:

   143

    typedef enum {

   144

      expression_vg,

   145

      assignment_vg,

   146

      fparam_output_vg

   147

    } variablegeneration_t;

   148

   149

  private:

   150

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

   151

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

   152

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

   153

     * or function currently being processed.

   154

     * The following object does just that...

   155

     * This object instance will then later be called while the

   156

     * remaining il code is being handled.

   157

     */

   158

    search_expression_type_c *search_expression_type;

   159

   160

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

   161

     * imediately after a parenthesis is opened.

   162

     * This variable is only used to pass data from the

   163

     * il_expression_c visitor to the simple_instr_list_c visitor.

   164

     *

   165

     * e.g.:

   166

     *         LD var1

   167

     *         AND ( var2

   168

     *         OR var3

   169

     *         )

   170

     *

   171

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

   172

     * an il_expression_c, where var2 should be loaded into the

   173

     * il default variable before continuing with the expression

   174

     * inside the parenthesis.

   175

     * Unfortunately, only the simple_instr_list_c may do the

   176

     * initial laoding of the var2 bariable following the parenthesis,

   177

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

   178

     * parameter to the simple_instr_list_c visitor.

   179

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

   180

     */

   181

    symbol_c *il_default_variable_init_value;

   182

   183

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

   184

    /* These variables are used to pass data from the

   185

     * il_simple_operation_c and il_expression_c visitors

   186

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

   187

     * LDN_operator_c, ST_operator_c, STN_operator_c, ...)

   188

     */

   189

    symbol_c *current_operand;

   190

    symbol_c *current_operand_type;

   191

   192

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

   193

    /* This variable is used to pass data from the

   194

     * il_jump_operation_c visitor

   195

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

   196

     * JMPC_operator_c, JMPCN_operator_c, ...)

   197

     */

   198

    symbol_c *jump_label;

   199

   200

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

   201

     * is a boolean variable.

   202

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

   203

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

   204

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

   205

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

   206

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

   207

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

   208

     * data type.

   209

     * The following object is it...

   210

     */

   211

    bool_type_name_c bool_type;

   212

    lint_type_name_c lint_type;

   213

    lword_type_name_c lword_type;

   214

    lreal_type_name_c lreal_type;

   215

   216

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

   217

    #define IL_DEFVAR_T VAR_LEADER "IL_DEFVAR_T"

   218

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

   219

    #define IL_DEFVAR   VAR_LEADER "IL_DEFVAR"

   220

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

   221

     * parenthesised instruction list to the immediately preceding

   222

     * scope ...

   223

     */

   224

    #define IL_DEFVAR_BACK   VAR_LEADER "IL_DEFVAR_BACK"

   225

    il_default_variable_c default_variable_name;

   226

    il_default_variable_c default_variable_back_name;

   227

   228

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

   229

     * by searching through the declarations of the variables currently

   230

     * in scope.

   231

     * This class does just that...

   232

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

   233

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

   234

     * This object instance will then later be called while the

   235

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

   236

     *

   237

     * Note that functions cannot contain calls to function blocks,

   238

     * so we do not create an object instance when handling

   239

     * a function declaration.

   240

     */

   241

    search_fb_instance_decl_c *search_fb_instance_decl;

   242

   243

    search_varfb_instance_type_c *search_varfb_instance_type;

   244

   245

    search_base_type_c search_base_type;

   246

   247

    int fcall_number;

   248

    symbol_c *fbname;

   249

   250

    variablegeneration_t wanted_variablegeneration;

   251

   252

  public:

   253

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

   254

    : generate_c_typedecl_c(s4o_ptr),

   255

      default_variable_name(IL_DEFVAR, NULL),

   256

      default_variable_back_name(IL_DEFVAR_BACK, NULL)

   257

    {

   258

      search_expression_type = new search_expression_type_c(scope);

   259

      search_fb_instance_decl = new search_fb_instance_decl_c(scope);

   260

      search_varfb_instance_type = new search_varfb_instance_type_c(scope);

   261

      current_operand = NULL;

   262

      current_operand_type = NULL;

   263

      il_default_variable_init_value = NULL;

   264

      fcall_number = 0;

   265

      fbname = name;

   266

      wanted_variablegeneration = expression_vg;

   267

      this->set_variable_prefix(variable_prefix);

   268

    }

   269

   270

    virtual ~generate_c_il_c(void) {

   271

      delete search_fb_instance_decl;

   272

      delete search_expression_type;

   273

      delete search_varfb_instance_type;

   274

    }

   275

   276

    void generate(instruction_list_c *il) {

   277

      il->accept(*this);

   278

    }

   279

   280

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

   281

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

   282

     */

   283

    void declare_backup_variable(void) {

   284

      s4o.print(s4o.indent_spaces);

   285

      s4o.print(IL_DEFVAR_T);

   286

      s4o.print(" ");

   287

      print_backup_variable();

   288

      s4o.print(";\n");

   289

    }

   290

   291

    void print_backup_variable(void) {

   292

      this->default_variable_back_name.accept(*this);

   293

    }

   294

   295

  private:

   296

    /* A helper function... */

   297

    /*

   298

    bool is_bool_type(symbol_c *type_symbol) {

   299

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

   300

    }

   301

    */

   302

   303

    /* A helper function... */

   304

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

   305

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

   306

      if (NULL == op) ERROR;

   307

   308

      lo->accept(*this);

   309

      s4o.print(op);

   310

      ro->accept(*this);

   311

      return NULL;

   312

    }

   313

   314

    /* A helper function... */

   315

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

   316

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

   317

      if (NULL == func) ERROR;

   318

   319

      lo->accept(*this);

   320

      s4o.print(" = ");

   321

      s4o.print(func);

   322

      s4o.print("(");

   323

      lo->accept(*this);

   324

      s4o.print(", ");

   325

      ro->accept(*this);

   326

      s4o.print(")");

   327

      return NULL;

   328

    }

   329

   330

    /* A helper function... */

   331

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

   332

      if (NULL == fb_name) ERROR;

   333

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

   334

      if (NULL == sv) ERROR;

   335

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

   336

      if (NULL == id) ERROR;

   337

   338

      identifier_c param(param_name);

   339

   340

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

   341

      il_assign_operator_c il_assign_operator(&param);

   342

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

   343

      // SYM_LIST(il_param_list_c)

   344

      il_param_list_c il_param_list;   

   345

      il_param_list.add_element(&il_param_assignment);

   346

      CAL_operator_c CAL_operator;

   347

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

   348

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

   349

   350

      il_fb_call.accept(*this);

   351

      return NULL;

   352

    }

   353

   354

    /* A helper function... */

   355

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

   356

      if (NULL == o) ERROR;

   357

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

   358

   359

      symbol_c *backup = this->default_variable_name.current_type;

   360

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

   361

      this->default_variable_name.accept(*this);

   362

      this->default_variable_name.current_type = backup;

   363

   364

      s4o.print(" = ");

   365

      s4o.print(operation);

   366

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

   367

      s4o.print("(__BOOL_LITERAL(TRUE), NULL, 2, ");

   368

      this->default_variable_name.accept(*this);

   369

      s4o.print(", ");

   370

      o->accept(*this);

   371

      s4o.print(")");

   372

   373

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

   374

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

   375

      return NULL;

   376

    }

   377

   378

   379

    /* A helper function... */

   380

    void C_modifier(void) {

   381

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

   382

        s4o.print("if (");

   383

        this->default_variable_name.accept(*this);

   384

        s4o.print(") ");

   385

      }

   386

      else {ERROR;}

   387

    }

   388

   389

    /* A helper function... */

   390

    void CN_modifier(void) {

   391

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

   392

        s4o.print("if (!");

   393

        this->default_variable_name.accept(*this);

   394

        s4o.print(") ");

   395

      }

   396

      else {ERROR;}

   397

    }

   398

   399

    void BYTE_operator_result_type(void) {

   400

      if (search_expression_type->is_literal_integer_type(this->default_variable_name.current_type)) {

   401

        if (search_expression_type->is_literal_integer_type(this->current_operand_type))

   402

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

   403

        else

   404

          this->default_variable_name.current_type = this->current_operand_type;

   405

      }

   406

      else if (search_expression_type->is_literal_integer_type(this->current_operand_type))

   407

    	  this->current_operand_type = this->default_variable_name.current_type;

   408

    }

   409

   410

    void NUM_operator_result_type(void) {

   411

      if (search_expression_type->is_literal_real_type(this->default_variable_name.current_type)) {

   412

        if (search_expression_type->is_literal_integer_type(this->current_operand_type) ||

   413

            search_expression_type->is_literal_real_type(this->current_operand_type))

   414

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

   415

        else

   416

          this->default_variable_name.current_type = this->current_operand_type;

   417

      }

   418

      else if (search_expression_type->is_literal_integer_type(this->default_variable_name.current_type)) {

   419

        if (search_expression_type->is_literal_integer_type(this->current_operand_type))

   420

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

   421

        else if (search_expression_type->is_literal_real_type(this->current_operand_type))

   422

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

   423

        else

   424

          this->default_variable_name.current_type = this->current_operand_type;

   425

      }

   426

      else if (search_expression_type->is_literal_integer_type(this->current_operand_type) ||

   427

               search_expression_type->is_literal_real_type(this->current_operand_type))

   428

        this->current_operand_type = this->default_variable_name.current_type;

   429

    }

   430

   431

   432

public:

   433

void *visit(il_default_variable_c *symbol) {

   434

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

   435

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

   436

  if (NULL != symbol->current_type) {

   437

    s4o.print(".");

   438

    if (search_expression_type->is_literal_integer_type(symbol->current_type))

   439

      this->lint_type.accept(*this);

   440

    else if (search_expression_type->is_literal_real_type(this->default_variable_name.current_type))

   441

      this->lreal_type.accept(*this);

   442

    else

   443

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

   444

    s4o.print("var");

   445

  }

   446

  return NULL;

   447

}

   448

   449

   450

private:

   451

   452

#if 0

   453

I NEED TO FIX THIS!!!

   454

TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO

   455

void *visit(eno_param_c *symbol) {

   456

  if (this->is_variable_prefix_null()) {

   457

    s4o.print("*");

   458

  }

   459

  else {

   460

    this->print_variable_prefix();

   461

  }

   462

  s4o.print("ENO");

   463

  return NULL;

   464

}

   465

TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO

   466

#endif

   467

   468

   469

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

   470

/* B 1.4 - Variables */

   471

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

   472

/* B 1.4 - Variables */

   473

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

   474

void *visit(symbolic_variable_c *symbol) {

   475

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

   476

  if (this->is_variable_prefix_null()) {

   477

    if (wanted_variablegeneration == fparam_output_vg) {

   478

      if (vartype == search_var_instance_decl_c::external_vt) {

   479

    	s4o.print(GET_EXTERNAL);

   480

    	s4o.print("(");

   481

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

   482

      }

   483

      else {

   484

    	s4o.print("&(");

   485

        generate_c_base_c::visit(symbol);

   486

      }

   487

      s4o.print(")");

   488

    }

   489

    else {

   490

      if (vartype == search_var_instance_decl_c::external_vt) {

   491

        s4o.print(GET_EXTERNAL);

   492

        s4o.print("(");

   493

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

   494

        s4o.print(")");

   495

      }

   496

      else

   497

    	generate_c_base_c::visit(symbol);

   498

    }

   499

  }

   500

  else {

   501

    switch (wanted_variablegeneration) {

   502

      case expression_vg:

   503

        if (vartype == search_var_instance_decl_c::external_vt) {

   504

    	  s4o.print(GET_EXTERNAL);

   505

    	  s4o.print("(");

   506

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

   507

        }

   508

        else {

   509

          if (vartype == search_var_instance_decl_c::located_vt)

   510

            s4o.print(GET_LOCATED);

   511

          else

   512

            s4o.print(GET_VAR);

   513

          s4o.print("(");

   514

          generate_c_base_c::visit(symbol);

   515

        }

   516

        s4o.print(")");

   517

		break;

   518

      case fparam_output_vg: