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 implicit 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 implicit 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 IL implicit 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 IL implicit 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

   114

  public:

   115

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

   116

    virtual void *accept(visitor_c &visitor);

   117

};

   118

   119

   120

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

   121

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

   122

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

   123

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

   124

   125

   126

   127

   128

   129

class generate_c_il_c: public generate_c_base_and_typeid_c, il_default_variable_visitor_c {

   130

   131

  public:

   132

    typedef enum {

   133

      expression_vg,

   134

      assignment_vg,

   135

      complextype_base_vg,

   136

      complextype_base_assignment_vg,

   137

      complextype_suffix_vg,

   138

      fparam_output_vg

   139

    } variablegeneration_t;

   140

   141

  private:

   142

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

   143

    /* This variable is used to pass data from the

   144

     * il_jump_operation_c visitor

   145

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

   146

     * JMPC_operator_c, JMPCN_operator_c, ...)

   147

     */

   148

    symbol_c *jump_label;

   149

   150

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

   151

    #define IL_DEFVAR_T VAR_LEADER "IL_DEFVAR_T"

   152

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

   153

    #define IL_DEFVAR   VAR_LEADER "IL_DEFVAR"

   154

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

   155

     * parenthesised instruction list to the immediately preceding

   156

     * scope ...

   157

     */

   158

    #define IL_DEFVAR_BACK   VAR_LEADER "IL_DEFVAR_BACK"

   159

   160

    il_default_variable_c implicit_variable_current;      /* the current   implicit variable, with the datatype resulting from the previous IL operation */

   161

    il_default_variable_c implicit_variable_result;       /* the resulting implicit variable, with the datatype resulting from the current  IL operation */

   162

    il_default_variable_c implicit_variable_result_back;

   163

   164

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

   165

    /* These variables are used to pass data from the

   166

     * il_simple_operation_c and il_expression_c visitors

   167

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

   168

     * LDN_operator_c, ST_operator_c, STN_operator_c, ...)

   169

     */

   170

    symbol_c *current_operand;

   171

   172

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

   173

     * by searching through the declarations of the variables currently

   174

     * in scope.

   175

     * This class does just that...

   176

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

   177

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

   178

     * This object instance will then later be called while the

   179

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

   180

     *

   181

     * Note that functions cannot contain calls to function blocks,

   182

     * so we do not create an object instance when handling

   183

     * a function declaration.

   184

     */

   185

    search_fb_instance_decl_c *search_fb_instance_decl;

   186

   187

    search_varfb_instance_type_c *search_varfb_instance_type;

   188

    search_var_instance_decl_c   *search_var_instance_decl;

   189

   190

    symbol_c* current_array_type;

   191

    symbol_c* current_param_type;

   192

   193

    int fcall_number;

   194

    symbol_c *fbname;

   195

   196

    variablegeneration_t wanted_variablegeneration;

   197

   198

  public:

   199

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

   200

    : generate_c_base_and_typeid_c(s4o_ptr),

   201

      implicit_variable_current    (IL_DEFVAR,      NULL),

   202

      implicit_variable_result     (IL_DEFVAR,      NULL),

   203

      implicit_variable_result_back(IL_DEFVAR_BACK, NULL)

   204

    {

   205

      search_fb_instance_decl    = new search_fb_instance_decl_c   (scope);

   206

      search_varfb_instance_type = new search_varfb_instance_type_c(scope);

   207

      search_var_instance_decl   = new search_var_instance_decl_c  (scope);

   208

   209

      current_operand = NULL;

   210

      current_array_type = NULL;

   211

      current_param_type = NULL;

   212

      fcall_number = 0;

   213

      fbname = name;

   214

      wanted_variablegeneration = expression_vg;

   215

      this->set_variable_prefix(variable_prefix);

   216

    }

   217

   218

    virtual ~generate_c_il_c(void) {

   219

      delete search_fb_instance_decl;

   220

      delete search_varfb_instance_type;

   221

      delete search_var_instance_decl;

   222

    }

   223

   224

    void generate(instruction_list_c *il) {

   225

      il->accept(*this);

   226

    }

   227

   228

  private:

   229

    /* Declare an implicit IL variable... */

   230

    void declare_implicit_variable(il_default_variable_c *implicit_var) {

   231

      s4o.print(s4o.indent_spaces);

   232

      s4o.print(IL_DEFVAR_T);

   233

      s4o.print(" ");

   234

      implicit_var->datatype = NULL;

   235

      implicit_var->accept(*this);

   236

      s4o.print(";\n");

   237

    }

   238

   239

  public:  

   240

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

   241

    void declare_implicit_variable(void) {

   242

      declare_implicit_variable(&this->implicit_variable_result);

   243

    }

   244

   245

    /* Declare the backup to the default variable, that will store the result of the IL operations executed inside a parenthesis... */

   246

    void declare_implicit_variable_back(void) {

   247

      declare_implicit_variable(&this->implicit_variable_result_back);

   248

    }

   249

   250

    void print_implicit_variable_back(void) {

   251

      this->implicit_variable_result_back.accept(*this);

   252

    }    

   253

   254

   255

  private:

   256

    /* a small helper function */

   257

    symbol_c *default_literal_type(symbol_c *symbol) {

   258

      if (get_datatype_info_c::is_ANY_INT_literal(symbol)) {

   259

        return &get_datatype_info_c::lint_type_name;

   260

      }

   261

      else if (get_datatype_info_c::is_ANY_REAL_literal(symbol)) {

   262

        return &get_datatype_info_c::lreal_type_name;

   263

      }

   264

      return symbol;

   265

    }

   266

   267

    /* A helper function... */

   268

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

   269

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

   270

   271

      lo->accept(*this);

   272

      s4o.print(op);

   273

      ro->accept(*this);

   274

      return NULL;

   275

    }

   276

   277

    /* A helper function... */

   278

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

   279

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

   280

      if  (NULL == func) ERROR;

   281

   282

      res->accept(*this);

   283

      s4o.print(" = ");

   284

      s4o.print(func);

   285

      s4o.print("(");

   286

      lo->accept(*this);

   287

      s4o.print(", ");

   288

      ro->accept(*this);

   289

      s4o.print(")");

   290

      return NULL;

   291

    }

   292

   293

    /* A helper function... used for implicit FB calls: S1, R1, CLK, CU, CD, PV, IN, and PT */

   294

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

   295

      if (wanted_variablegeneration != expression_vg) {

   296

        s4o.print(param_name);

   297

        return NULL;

   298

      }

   299

   300

      if (NULL == fb_name) ERROR;

   301

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

   302

      if (NULL == sv) ERROR;

   303

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

   304

      if (NULL == id) ERROR;

   305

   306

      identifier_c param(param_name);

   307

   308

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

   309

      il_assign_operator_c il_assign_operator(&param);

   310

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

   311

      // SYM_LIST(il_param_list_c)

   312

      il_param_list_c il_param_list;   

   313

      il_param_list.add_element(&il_param_assignment);

   314

      CAL_operator_c CAL_operator;

   315

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

   316

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

   317

   318

      il_fb_call.accept(*this);

   319

      return NULL;

   320

    }

   321

   322

    /* A helper function... */

   323

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

   324

      if (NULL == operand) ERROR;

   325

      if (NULL == operand->datatype) ERROR;

   326

      if (NULL == this->implicit_variable_current.datatype) ERROR;

   327

   328

      this->implicit_variable_result.accept(*this);

   329

      s4o.print(" = ");

   330

      // print_compare_function is in generate_c_base_c, which is inherited by generate_c_il_c

   331

      print_compare_function(operation, operand->datatype, &(this->implicit_variable_current), operand);

   332

      return NULL;

   333

    }

   334

   335

   336

    /* A helper function... */

   337

    void C_modifier(void) {

   338

      if (!get_datatype_info_c::is_BOOL_compatible(implicit_variable_current.datatype)) ERROR;

   339

      s4o.print("if (");

   340

      this->implicit_variable_current.accept(*this);

   341

      s4o.print(") ");

   342

    }

   343

   344

    /* A helper function... */

   345

    void CN_modifier(void) {

   346

      if (!get_datatype_info_c::is_BOOL_compatible(implicit_variable_current.datatype)) ERROR;

   347

      s4o.print("if (!");

   348

      this->implicit_variable_current.accept(*this);

   349

      s4o.print(") ");

   350

    }

   351

   352

   353

    void *print_getter(symbol_c *symbol) {

   354

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

   355

      if (wanted_variablegeneration == fparam_output_vg) {

   356

        if (vartype == search_var_instance_decl_c::external_vt) {

   357

          if (!get_datatype_info_c::is_type_valid    (symbol->datatype)) ERROR;

   358

          if ( get_datatype_info_c::is_function_block(symbol->datatype))

   359

            s4o.print(GET_EXTERNAL_FB_BY_REF);

   360

          else

   361

            s4o.print(GET_EXTERNAL_BY_REF);

   362

        }

   363

        else if (vartype == search_var_instance_decl_c::located_vt)

   364

          s4o.print(GET_LOCATED_BY_REF);

   365

        else

   366

          s4o.print(GET_VAR_BY_REF);

   367

      }

   368

      else {

   369

        if (vartype == search_var_instance_decl_c::external_vt) {

   370

          if (!get_datatype_info_c::is_type_valid    (symbol->datatype)) ERROR;

   371

          if ( get_datatype_info_c::is_function_block(symbol->datatype))

   372

            s4o.print(GET_EXTERNAL_FB);

   373

          else

   374

            s4o.print(GET_EXTERNAL);

   375

        }

   376

        else if (vartype == search_var_instance_decl_c::located_vt)

   377

          s4o.print(GET_LOCATED);

   378

        else

   379

          s4o.print(GET_VAR);

   380

      }

   381

      s4o.print("(");

   382

   383

      variablegeneration_t old_wanted_variablegeneration = wanted_variablegeneration;

   384

      wanted_variablegeneration = complextype_base_vg;

   385

      symbol->accept(*this);

   386

      s4o.print(",");

   387

      wanted_variablegeneration = complextype_suffix_vg;

   388

      symbol->accept(*this);

   389

      s4o.print(")");

   390

      wanted_variablegeneration = old_wanted_variablegeneration;

   391

      return NULL;

   392

    }

   393

   394

    void *print_setter(symbol_c* symbol,

   395

            symbol_c* type,

   396

            symbol_c* value,

   397

            symbol_c* fb_symbol = NULL,

   398

            symbol_c* fb_value = NULL,

   399

            bool negative = false) {

   400

   401

      bool type_is_complex = false;

   402

      if (fb_symbol == NULL) {

   403

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

   404

        type_is_complex = analyse_variable_c::contains_complex_type(symbol);

   405

        if (vartype == search_var_instance_decl_c::external_vt) {

   406

          if (!get_datatype_info_c::is_type_valid    (symbol->datatype)) ERROR;

   407

          if ( get_datatype_info_c::is_function_block(symbol->datatype))

   408

            s4o.print(SET_EXTERNAL_FB);

   409

          else

   410

            s4o.print(SET_EXTERNAL);

   411

        }

   412

        else if (vartype == search_var_instance_decl_c::located_vt)

   413

          s4o.print(SET_LOCATED);

   414

        else

   415

          s4o.print(SET_VAR);

   416

      }

   417

      else {

   418

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

   419

        if (vartype == search_var_instance_decl_c::external_vt)

   420

          s4o.print(SET_EXTERNAL_FB);

   421

        else

   422

          s4o.print(SET_VAR);

   423

      }

   424

      s4o.print("(");

   425

   426

      if (fb_symbol != NULL) {

   427

        print_variable_prefix();

   428

        fb_symbol->accept(*this);

   429

        s4o.print(".,");

   430

      }

   431

      else if (type_is_complex)

   432

        wanted_variablegeneration = complextype_base_assignment_vg;

   433

      else

   434

        wanted_variablegeneration = assignment_vg;

   435

      symbol->accept(*this);

   436

/*

   437

      s4o.print(",");

   438

      if (negative) {

   439

        if (get_datatype_info_c::is_BOOL_compatible(this->current_operand->datatype))

   440

          s4o.print("!");

   441

        else

   442

          s4o.print("~");

   443

      }

   444

      wanted_variablegeneration = expression_vg;

   445

      print_check_function(type, value, fb_value);

   446

      if (type_is_complex) {

   447

        s4o.print(",");

   448

        wanted_variablegeneration = complextype_suffix_vg;

   449

        symbol->accept(*this);

   450

      }

   451

      s4o.print(")");

   452

      wanted_variablegeneration = expression_vg;

   453

      return NULL;

   454

*/

   455

      s4o.print(",");

   456

      if (type_is_complex) {

   457

        wanted_variablegeneration = complextype_suffix_vg;

   458

        symbol->accept(*this);

   459

      }

   460

      s4o.print(",");

   461

      if (negative) {

   462

        if (get_datatype_info_c::is_BOOL_compatible(this->current_operand->datatype))

   463

          s4o.print("!");

   464

        else

   465

          s4o.print("~");

   466

      }

   467

      wanted_variablegeneration = expression_vg;

   468

      print_check_function(type, value, fb_value);

   469

      s4o.print(")");

   470

      wanted_variablegeneration = expression_vg;

   471

      return NULL;

   472

    }

   473

   474

public:

   475

void *visit(il_default_variable_c *symbol) {

   476

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

   477

  if (NULL != symbol->datatype) {

   478

    s4o.print(".");

   479

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

   480

    s4o.print("var");

   481

  } return NULL;

   482

}

   483

   484

   485

private:

   486

   487

   488

   489

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

   490

/* B 1.3.3 - Derived data types */

   491

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

   492

   493

/*  signed_integer DOTDOT signed_integer */

   494

void *visit(subrange_c *symbol) {

   495

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

   496

  return NULL;

   497

}

   498

   499

/* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */

   500

void *visit(array_specification_c *symbol) {

   501

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