1

/*

     2

 *  matiec - a compiler for the programming languages defined in IEC 61131-3

     3

 *

     4

 *  Copyright (C) 2003-2011  Mario de Sousa (msousa@fe.up.pt)

     5

 *  Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant

     6

 *

     7

 *  This program is free software: you can redistribute it and/or modify

     8

 *  it under the terms of the GNU General Public License as published by

     9

 *  the Free Software Foundation, either version 3 of the License, or

    10

 *  (at your option) any later version.

    11

 *

    12

 *  This program is distributed in the hope that it will be useful,

    13

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    14

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    15

 *  GNU General Public License for more details.

    16

 *

    17

 *  You should have received a copy of the GNU General Public License

    18

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

    19

 *

    20

 *

    21

 * This code is made available on the understanding that it will not be

    22

 * used in safety-critical situations without a full and competent review.

    23

 */

    24

    25

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

    26

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

    27

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

    28

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

    29

    30

/* Returns the data type of an il_operand.

    31

 *

    32

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

    33

 * we return the type of the variable instance.

    34

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

    35

 * we return the data type of that constant.

    36

 *

    37

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

    38

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

    39

 *

    40

 * The class constructor must be given the search scope

    41

 * (function, function block or program within which

    42

 * the possible il_operand variable instance was declared).

    43

 */

    44

    45

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

    46

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

    47

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

    48

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

    49

    50

    51

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

    52

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

    53

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

    54

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

    55

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

    56

 *

    57

 * Nevertheless, the basic visitor class visitor_c does not know

    58

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

    59

 * to extend that too.

    60

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

    61

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

    62

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

    63

 * than the alternative...

    64

 */

    65

class il_default_variable_c;

    66

    67

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

    68

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

    69

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

    70

 */

    71

class il_default_variable_visitor_c {

    72

  public:

    73

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

    74

    75

    virtual ~il_default_variable_visitor_c(void) {return;}

    76

};

    77

    78

    79

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

    80

 * the IL default variable name.

    81

 *

    82

 * It includes a reference to its name,

    83

 * and the data type of the data currently stored

    84

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

    85

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

    86

 * of the union top reference!!

    87

 *

    88

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

    89

 * the value currently being stored in the default variable.

    90

 * This is required so we can process parenthesis,

    91

 *

    92

 * e.g. :

    93

 *         LD var1

    94

 *         AND (

    95

 *         LD var2

    96

 *         OR var3

    97

 *         )

    98

 *

    99

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

   100

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

   101

 * instructions inside the parenthesis.

   102

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

   103

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

   104

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

   105

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

   106

 *

   107

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

   108

 * to track this!

   109

 */

   110

class il_default_variable_c: public symbol_c {

   111

  public:

   112

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

   113

    symbol_c *current_type;

   114

   115

  public:

   116

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

   117

    virtual void *accept(visitor_c &visitor);

   118

};

   119

   120

   121

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

   122

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

   123

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

   124

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

   125

   126

   127

   128

class generate_c_il_c: public generate_c_typedecl_c, il_default_variable_visitor_c {

   129

   130

  public:

   131

    typedef enum {

   132

      expression_vg,

   133

      assignment_vg,

   134

      complextype_base_vg,

   135

      complextype_base_assignment_vg,

   136

      complextype_suffix_vg,

   137

      fparam_output_vg

   138

    } variablegeneration_t;

   139

   140

  private:

   141

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

   142

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

   143

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

   144

     * or function currently being processed.

   145

     * The following object does just that...

   146

     * This object instance will then later be called while the

   147

     * remaining il code is being handled.

   148

     */

   149

    search_expression_type_c *search_expression_type;

   150

   151

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

   152

     * imediately after a parenthesis is opened.

   153

     * This variable is only used to pass data from the

   154

     * il_expression_c visitor to the simple_instr_list_c visitor.

   155

     *

   156

     * e.g.:

   157

     *         LD var1

   158

     *         AND ( var2

   159

     *         OR var3

   160

     *         )

   161

     *

   162

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

   163

     * an il_expression_c, where var2 should be loaded into the

   164

     * il default variable before continuing with the expression

   165

     * inside the parenthesis.

   166

     * Unfortunately, only the simple_instr_list_c may do the

   167

     * initial laoding of the var2 bariable following the parenthesis,

   168

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

   169

     * parameter to the simple_instr_list_c visitor.

   170

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

   171

     */

   172

    symbol_c *il_default_variable_init_value;

   173

   174

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

   175

    /* These variables are used to pass data from the

   176

     * il_simple_operation_c and il_expression_c visitors

   177

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

   178

     * LDN_operator_c, ST_operator_c, STN_operator_c, ...)

   179

     */

   180

    symbol_c *current_operand;

   181

    symbol_c *current_operand_type;

   182

   183

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

   184

    /* This variable is used to pass data from the

   185

     * il_jump_operation_c visitor

   186

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

   187

     * JMPC_operator_c, JMPCN_operator_c, ...)

   188

     */

   189

    symbol_c *jump_label;

   190

   191

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

   192

     * is a boolean variable.

   193

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

   194

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

   195

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

   196

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

   197

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

   198

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

   199

     * data type.

   200

     * The following object is it...

   201

     */

   202

    bool_type_name_c bool_type;

   203

    lint_type_name_c lint_type;

   204

    lword_type_name_c lword_type;

   205

    lreal_type_name_c lreal_type;

   206

   207

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

   208

    #define IL_DEFVAR_T VAR_LEADER "IL_DEFVAR_T"

   209

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

   210

    #define IL_DEFVAR   VAR_LEADER "IL_DEFVAR"

   211

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

   212

     * parenthesised instruction list to the immediately preceding

   213

     * scope ...

   214

     */

   215

    #define IL_DEFVAR_BACK   VAR_LEADER "IL_DEFVAR_BACK"

   216

    il_default_variable_c default_variable_name;

   217

    il_default_variable_c default_variable_back_name;

   218

   219

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

   220

     * by searching through the declarations of the variables currently

   221

     * in scope.

   222

     * This class does just that...

   223

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

   224

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

   225

     * This object instance will then later be called while the

   226

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

   227

     *

   228

     * Note that functions cannot contain calls to function blocks,

   229

     * so we do not create an object instance when handling

   230

     * a function declaration.

   231

     */

   232

    search_fb_instance_decl_c *search_fb_instance_decl;

   233

   234

    search_varfb_instance_type_c *search_varfb_instance_type;

   235

    search_var_instance_decl_c   *search_var_instance_decl;

   236

   237

    symbol_c* current_array_type;

   238

    symbol_c* current_param_type;

   239

   240

    int fcall_number;

   241

    symbol_c *fbname;

   242

   243

    variablegeneration_t wanted_variablegeneration;

   244

   245

  public:

   246

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

   247

    : generate_c_typedecl_c(s4o_ptr),

   248

      default_variable_name(IL_DEFVAR, NULL),

   249

      default_variable_back_name(IL_DEFVAR_BACK, NULL)

   250

    {

   251

      search_expression_type = new search_expression_type_c(scope);

   252

      search_fb_instance_decl = new search_fb_instance_decl_c(scope);

   253

      search_varfb_instance_type = new search_varfb_instance_type_c(scope);

   254

      search_var_instance_decl   = new search_var_instance_decl_c(scope);

   255

   256

      current_operand = NULL;

   257

      current_operand_type = NULL;

   258

      il_default_variable_init_value = NULL;

   259

      current_array_type = NULL;

   260

      current_param_type = NULL;

   261

      fcall_number = 0;

   262

      fbname = name;

   263

      wanted_variablegeneration = expression_vg;

   264

      this->set_variable_prefix(variable_prefix);

   265

    }

   266

   267

    virtual ~generate_c_il_c(void) {

   268

      delete search_fb_instance_decl;

   269

      delete search_expression_type;

   270

      delete search_varfb_instance_type;

   271

      delete search_var_instance_decl;

   272

    }

   273

   274

    void generate(instruction_list_c *il) {

   275

      il->accept(*this);

   276

    }

   277

   278

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

   279

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

   280

     */

   281

    void declare_backup_variable(void) {

   282

      s4o.print(s4o.indent_spaces);

   283

      s4o.print(IL_DEFVAR_T);

   284

      s4o.print(" ");

   285

      print_backup_variable();

   286

      s4o.print(";\n");

   287

    }

   288

   289

    void print_backup_variable(void) {

   290

      this->default_variable_back_name.accept(*this);

   291

    }

   292

   293

    void reset_default_variable_name(void) {

   294

      this->default_variable_name.current_type = NULL;

   295

      this->default_variable_back_name.current_type = NULL;

   296

    }

   297

   298

  private:

   299

    /* A helper function... */

   300

    /*

   301

    bool is_bool_type(symbol_c *type_symbol) {

   302

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

   303

    }

   304

    */

   305

   306

    /* A helper function... */

   307

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

   308

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

   309

      if (NULL == op) ERROR;

   310

   311

      lo->accept(*this);

   312

      s4o.print(op);

   313

      ro->accept(*this);

   314

      return NULL;

   315

    }

   316

   317

    /* A helper function... */

   318

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

   319

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

   320

      if (NULL == func) ERROR;

   321

   322

      lo->accept(*this);

   323

      s4o.print(" = ");

   324

      s4o.print(func);

   325

      s4o.print("(");

   326

      lo->accept(*this);

   327

      s4o.print(", ");

   328

      ro->accept(*this);

   329

      s4o.print(")");

   330

      return NULL;

   331

    }

   332

   333

    /* A helper function... */

   334

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

   335

      if (wanted_variablegeneration != expression_vg) {

   336

        s4o.print(param_name);

   337

        return NULL;

   338

      }

   339

   340

      if (NULL == fb_name) ERROR;

   341

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

   342

      if (NULL == sv) ERROR;

   343

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

   344

      if (NULL == id) ERROR;

   345

   346

      identifier_c param(param_name);

   347

   348

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

   349

      il_assign_operator_c il_assign_operator(&param);

   350

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

   351

      // SYM_LIST(il_param_list_c)

   352

      il_param_list_c il_param_list;   

   353

      il_param_list.add_element(&il_param_assignment);

   354

      CAL_operator_c CAL_operator;

   355

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

   356

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

   357

   358

      il_fb_call.accept(*this);

   359

      return NULL;

   360

    }

   361

   362

    /* A helper function... */

   363

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

   364

      if (NULL == o) ERROR;

   365

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

   366

   367

      symbol_c *backup = this->default_variable_name.current_type;

   368

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

   369

      this->default_variable_name.accept(*this);

   370

      this->default_variable_name.current_type = backup;

   371

   372

      s4o.print(" = ");

   373

      s4o.print(operation);

   374

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

   375

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

   376

      this->default_variable_name.accept(*this);

   377

      s4o.print(", ");

   378

      o->accept(*this);

   379

      s4o.print(")");

   380

   381

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

   382

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

   383

      return NULL;

   384

    }

   385

   386

   387

    /* A helper function... */

   388

    void C_modifier(void) {

   389

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

   390

        s4o.print("if (");

   391

        this->default_variable_name.accept(*this);

   392

        s4o.print(") ");

   393

      }

   394

      else {ERROR;}

   395

    }

   396

   397

    /* A helper function... */

   398

    void CN_modifier(void) {

   399

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

   400

        s4o.print("if (!");

   401

        this->default_variable_name.accept(*this);

   402

        s4o.print(") ");

   403

      }

   404

      else {ERROR;}

   405

    }

   406

   407

    void BYTE_operator_result_type(void) {

   408

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

   409

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

   410

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

   411

        else

   412

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

   413

      }

   414

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

   415

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

   416

    }

   417

   418

    void NUM_operator_result_type(void) {

   419

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

   420

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

   421

            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->default_variable_name.current_type)) {

   427

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

   428

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

   429

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

   430

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

   431

        else

   432

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

   433

      }

   434

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

   435

               search_expression_type->is_literal_real_type(this->current_operand_type))

   436

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

   437

    }

   438

   439

    void *print_getter(symbol_c *symbol) {

   440

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

   441

      if (wanted_variablegeneration == fparam_output_vg) {

   442

      	if (vartype == search_var_instance_decl_c::external_vt)

   443

          s4o.print(GET_EXTERNAL_BY_REF);

   444

        else if (vartype == search_var_instance_decl_c::located_vt)

   445

          s4o.print(GET_LOCATED_BY_REF);

   446

        else

   447

          s4o.print(GET_VAR_BY_REF);

   448

      }

   449

      else {

   450

    	if (vartype == search_var_instance_decl_c::external_vt)

   451

    	  s4o.print(GET_EXTERNAL);

   452

    	else if (vartype == search_var_instance_decl_c::located_vt)

   453

    	  s4o.print(GET_LOCATED);

   454

    	else

   455

    	  s4o.print(GET_VAR);

   456

      }

   457

      s4o.print("(");

   458

   459

      variablegeneration_t old_wanted_variablegeneration = wanted_variablegeneration;

   460

      wanted_variablegeneration = complextype_base_vg;

   461

      symbol->accept(*this);

   462

      if (search_var_instance_decl->type_is_complex(symbol))

   463

        s4o.print(",");

   464

      wanted_variablegeneration = complextype_suffix_vg;

   465

      symbol->accept(*this);

   466

      s4o.print(")");

   467

      wanted_variablegeneration = old_wanted_variablegeneration;

   468

      return NULL;

   469

    }

   470

   471

    void *print_setter(symbol_c* symbol,

   472

    		symbol_c* type,

   473

    		symbol_c* value,

   474

    		symbol_c* fb_symbol = NULL,

   475

    		symbol_c* fb_value = NULL,

   476

    		bool negative = false) {

   477

   478

      bool type_is_complex = false;

   479

      if (fb_symbol == NULL) {

   480

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

   481

        type_is_complex = search_var_instance_decl->type_is_complex(symbol);

   482

        if (vartype == search_var_instance_decl_c::external_vt)

   483

          s4o.print(SET_EXTERNAL);

   484

        else if (vartype == search_var_instance_decl_c::located_vt)

   485

          s4o.print(SET_LOCATED);

   486

        else

   487

          s4o.print(SET_VAR);

   488

      }

   489

      else

   490

        s4o.print(SET_VAR);

   491

      s4o.print("(");

   492

   493

      if (fb_symbol != NULL) {

   494

        print_variable_prefix();

   495

        fb_symbol->accept(*this);

   496

        s4o.print(".,");

   497

      }

   498

      else if (type_is_complex)

   499

        wanted_variablegeneration = complextype_base_assignment_vg;

   500

      else

   501

        wanted_variablegeneration = assignment_vg;

   502

   503

      symbol->accept(*this);

   504

      s4o.print(",");

   505

      if (negative) {

   506

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

   507

		  s4o.print("!");

   508

	    else

   509

		  s4o.print("~");

   510

      }

   511

      wanted_variablegeneration = expression_vg;

   512

      print_check_function(type, value, fb_value);

   513

      if (type_is_complex) {