1

/*

     2

 * (c) 2007 Mario de Sousa and Laurent Bessard

     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

 * This is one of the versions available for the 4th stage.

    27

 *

    28

 * This 4th stage generates a c++ source program equivalent

    29

 * to the IL and ST code.

    30

 */

    31

    32

    33

#define INLINE_RESULT_TEMP_VAR "__res"

    34

    36

    37

  public:

    38

    typedef enum {

    39

      expression_vg,

    40

      assignment_vg,

    41

      complextype_base_vg,

    42

      complextype_suffix_vg

    43

    } variablegeneration_t;

    44

    45

  private:

    46

    47

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

    48

	#define IL_DEFVAR   VAR_LEADER "IL_DEFVAR"

    49

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

    50

	 * parenthesised instruction list to the immediately preceding

    51

	 * scope ...

    52

	 */

    53

	il_default_variable_c default_variable_name;

    54

    55

	symbol_c* current_array_type;

    56

    57

	int fcall_number;

    58

	symbol_c *fbname;

    59

    60

    search_expression_type_c *search_expression_type;

    61

    62

    search_varfb_instance_type_c *search_varfb_instance_type;

    63

    64

    search_base_type_c search_base_type;

    65

    66

    variablegeneration_t wanted_variablegeneration;

    67

    68

  public:

    70

    : generate_c_typedecl_c(s4o_ptr),

    71

      default_variable_name(IL_DEFVAR, NULL)

    72

    {

    73

      search_expression_type = new search_expression_type_c(scope);

    74

      search_varfb_instance_type = new search_varfb_instance_type_c(scope);

    75

      this->set_variable_prefix(variable_prefix);

    76

      fcall_number = 0;

    77

      fbname = name;

    78

      wanted_variablegeneration = expression_vg;

    79

    }

    80

    83

      delete search_varfb_instance_type;

    84

    }

    85

    98

    99

      fcall_number++;

   100

   101

      s4o.print(s4o.indent_spaces);

   102

      s4o.print("inline ");

   103

      return_data_type->accept(*this);

   104

      s4o.print(" __");

   105

      fbname->accept(*this);

   106

      s4o.print("_");

   107

      function_name->accept(*this);

   108

      s4o.print_integer(fcall_number);

   109

      s4o.print("(");

   110

      s4o.indent_right();

   111

   112

      PARAM_LIST_ITERATOR() {

   113

        if (PARAM_DIRECTION == function_param_iterator_c::direction_in) {

   114

          PARAM_TYPE->accept(*this);

   115

          s4o.print(" ");

   116

          PARAM_NAME->accept(*this);

   117

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

   118

        }

   119

      }

   120

      fbname->accept(*this);

   121

	  s4o.print(" *");

   122

	  s4o.print(FB_FUNCTION_PARAM);

   123

	  s4o.indent_left();

   124

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

   125

	  s4o.print("{\n");

   126

      s4o.indent_right();

   127

   128

      s4o.print(s4o.indent_spaces);

   129

      return_data_type->accept(*this);

   130

      s4o.print(" "),

   131

      s4o.print(INLINE_RESULT_TEMP_VAR);

   132

      s4o.print(";\n");

   133

   134

	  PARAM_LIST_ITERATOR() {

   135

		if ((PARAM_DIRECTION == function_param_iterator_c::direction_out ||

   136

		     PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&

   137

		    PARAM_VALUE != NULL) {

   138

		  s4o.print(s4o.indent_spaces);

   139

		  PARAM_TYPE->accept(*this);

   140

          s4o.print(" ");

   141

          s4o.print(TEMP_VAR);

   142

          PARAM_NAME->accept(*this);

   143

          s4o.print(" = ");

   144

          print_check_function(PARAM_TYPE, PARAM_VALUE);

   145

          s4o.print(";\n");

   146

		}

   147

	  }

   148

   149

	  s4o.print(s4o.indent_spaces + INLINE_RESULT_TEMP_VAR),

   150

			  s4o.print(" = ");

   151

	  function_name->accept(*this);

   152

	  s4o.print("(");

   153

	  s4o.indent_right();

   154

   155

	  PARAM_LIST_ITERATOR() {

   156

		if (pt != param_list.begin())

   157

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

   158

		if (PARAM_DIRECTION == function_param_iterator_c::direction_in)

   159

		  PARAM_NAME->accept(*this);

   160

		else if (PARAM_VALUE != NULL){

   161

          s4o.print("&");

   162

          s4o.print(TEMP_VAR);

   163

          PARAM_NAME->accept(*this);

   164

        }

   165

		else {

   166

		  s4o.print("NULL");

   167

		}

   168

	  }

   169

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

   170

	  s4o.indent_left();

   171

   172

	  PARAM_LIST_ITERATOR() {

   173

        if ((PARAM_DIRECTION == function_param_iterator_c::direction_out ||

   174

        	 PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&

   175

        	PARAM_VALUE != NULL) {

   176

   177

          s4o.print(s4o.indent_spaces);

   178

          print_setter(PARAM_VALUE, PARAM_TYPE, PARAM_NAME);

   179

          s4o.print(";\n");

   180

		}

   181

	  }

   182

	  s4o.print(s4o.indent_spaces + "return ");

   183

	  s4o.print(INLINE_RESULT_TEMP_VAR);

   184

	  s4o.print(";\n");

   185

   186

      s4o.indent_left();

   187

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

   188

    }

   189

   190

  private:

   191

   192

    void *print_getter(symbol_c *symbol) {

   193

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

   194

      if (vartype == search_var_instance_decl_c::external_vt)

   195

    	s4o.print(GET_EXTERNAL);

   196

      else if (vartype == search_var_instance_decl_c::located_vt)

   197

    	s4o.print(GET_LOCATED);

   198

      else

   199

    	s4o.print(GET_VAR);

   200

      s4o.print("(");

   201

   202

      wanted_variablegeneration = complextype_base_vg;

   203

      symbol->accept(*this);

   204

      if (search_varfb_instance_type->type_is_complex())

   205

    	s4o.print(",");

   206

      wanted_variablegeneration = complextype_suffix_vg;

   207

      symbol->accept(*this);

   208

      s4o.print(")");

   209

      wanted_variablegeneration = expression_vg;

   210

      return NULL;

   211

    }

   212

   213

    void *print_setter(symbol_c* symbol,

   214

    		symbol_c* type,

   215

    		symbol_c* value) {

   216

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

   217

      if (vartype == search_var_instance_decl_c::external_vt) {

   218

        symbolic_variable_c *variable = dynamic_cast<symbolic_variable_c *>(symbol);

   219

        /* TODO Find a solution for forcing global complex variables */

   220

        if (variable != NULL) {

   221

          s4o.print(SET_EXTERNAL);

   222

          s4o.print("(");

   223

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

   224

          s4o.print(",");

   225

        }

   226

        else {

   227

          s4o.print(SET_COMPLEX_EXTERNAL);

   228

          s4o.print("(");

   229

        }

   230

      }

   231

      else {

   232

        if (vartype == search_var_instance_decl_c::located_vt)

   233

          s4o.print(SET_LOCATED);

   234

        else

   235

          s4o.print(SET_VAR);

   236

        s4o.print("(");

   237

      }

   238

   239

      wanted_variablegeneration = complextype_base_vg;

   240

      symbol->accept(*this);

   241

      s4o.print(",");

   242

      wanted_variablegeneration = expression_vg;

   243

      print_check_function(type, value, NULL, true);

   244

      if (search_varfb_instance_type->type_is_complex()) {

   245

        s4o.print(",");

   246

        wanted_variablegeneration = complextype_suffix_vg;

   247

        symbol->accept(*this);

   248

      }

   249

      s4o.print(")");

   250

      wanted_variablegeneration = expression_vg;

   251

      return NULL;

   252

    }

   253

   254

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

   255

    /* B 1.4 - Variables */

   256

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

   257

    void *visit(symbolic_variable_c *symbol) {

   258

      unsigned int vartype;

   259

      if (wanted_variablegeneration == complextype_base_vg)

   260

        generate_c_base_c::visit(symbol);

   261

      else if (wanted_variablegeneration == complextype_suffix_vg)

   262

        return NULL;

   263

      else if (wanted_variablegeneration == expression_vg) {

   264

	    vartype = search_varfb_instance_type->get_vartype(symbol);

   265

	    if (vartype == search_var_instance_decl_c::external_vt) {

   266

		  s4o.print(GET_EXTERNAL);

   267

		  s4o.print("(");

   268

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

   269

	    }

   270

	    else {

   271

		  if (vartype == search_var_instance_decl_c::located_vt)

   272

		    s4o.print(GET_LOCATED);

   273

		  else

   274

		    s4o.print(GET_VAR);

   275

		  s4o.print("(");

   276

		  generate_c_base_c::visit(symbol);

   277

	    }

   278

	    s4o.print(")");

   279

      }

   280

      else

   281

        generate_c_base_c::visit(symbol);

   282

      return NULL;

   283

    }

   284

   285

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

   286

    /* B.1.4.1   Directly Represented Variables */

   287

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

   288

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

   289

    void *visit(direct_variable_c *symbol) {

   290

      TRACE("direct_variable_c");

   291

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

   292

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

   293

      s4o.print(GET_LOCATED);

   294

      s4o.print("(");

   295

      this->print_variable_prefix();

   296

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

   297

      s4o.print(")");

   298

      return NULL;

   299

    }

   300

   301

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

   302

    /* B.1.4.2   Multi-element Variables */

   303

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

   304

   305

    // SYM_REF2(structured_variable_c, record_variable, field_selector)

   306

    void *visit(structured_variable_c *symbol) {

   307

      TRACE("structured_variable_c");

   308

      switch (wanted_variablegeneration) {

   309

        case complextype_base_vg:

   310

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

   311

          break;

   312

        case complextype_suffix_vg:

   313

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

   314

          s4o.print(".");

   315

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

   316

          break;

   317

        default:

   318

          if (this->is_variable_prefix_null()) {

   319

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

   320

        	s4o.print(".");

   321

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

   322

          }

   323

          else

   324

        	print_getter(symbol);

   325

          break;

   326

      }

   327

      return NULL;

   328

    }

   329

   330

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

   331

    //SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   332

    void *visit(array_variable_c *symbol) {

   333

      switch (wanted_variablegeneration) {

   334

        case complextype_base_vg:

   335

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

   336

          break;

   337

        case complextype_suffix_vg:

   338

          current_array_type = search_varfb_instance_type->get_rawtype(symbol->subscripted_variable);

   339

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

   340

          if (current_array_type != NULL) {

   341

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

   342

            current_array_type = NULL;

   343

          }

   344

          break;

   345

        default:

   346

          if (this->is_variable_prefix_null()) {

   347

        	current_array_type = search_varfb_instance_type->get_rawtype(symbol->subscripted_variable);

   348

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

   349

        	if (current_array_type != NULL) {

   350

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

   351

        	  current_array_type = NULL;

   352

        	}

   353

          }

   354

          else

   355

        	print_getter(symbol);

   356

          break;

   357

      }

   358

      return NULL;

   359

    }

   360

   361

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

   362

    /* B.2 - Language IL (Instruction List) */

   363

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

   364

   365

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

   366

    /* B 2.1 Instructions and Operands */

   367

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

   368

   369

    void *visit(il_function_call_c *symbol) {

   370

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

   371

   372

	  if (f_decl != function_symtable.end_value()) {

   373

		DECLARE_PARAM_LIST()

   374

		bool has_output_params = false;

   375

   376

		/* determine the base data type returned by the function being called... */

   377

		search_base_type_c search_base_type;

   378

		symbol_c *return_data_type = (symbol_c *)f_decl->type_name->accept(search_base_type);

   379

		if (NULL == return_data_type) ERROR;

   380

   381

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

   382

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

   383

		 */

   384

   385

		function_param_iterator_c fp_iterator(f_decl);

   386

		identifier_c *param_name;

   387

		function_call_param_iterator_c function_call_param_iterator(symbol);

   388

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

   389

		  symbol_c *param_type = fp_iterator.param_type();

   390

		  if (param_type == NULL) ERROR;

   391

   392

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

   393

   394

		  symbol_c *param_value = NULL;

   395

   396

		  /* if it is the first parameter, semantics specifies that we should

   397

		   * get the value off the IL default variable!

   398

		   */

   399

		  if (1 == i)

   400

		    param_value = &this->default_variable_name;

   401

   402

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

   403

		  /* NOTE: the following line of code is not required in this case, but it doesn't

   404

		   * harm to leave it in, as in the case of a non-formal syntax function call,

   405

		   * it will always return NULL.

   406

		   * We leave it in in case we later decide to merge this part of the code together

   407

		   * with the function calling code in generate_c_st_c, which does require

   408

		   * the following line...

   409

		   */

   410

		  if (param_value == NULL)

   411

			param_value = function_call_param_iterator.search_f(param_name);

   412

   413

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

   414

          if (param_value == NULL) {

   415

            param_value = function_call_param_iterator.next_nf();

   416

            if (param_value != NULL && fp_iterator.is_en_eno_param_implicit()) ERROR;

   417

          }

   418

   419

		  if (param_value == NULL && param_direction == function_param_iterator_c::direction_in) {

   420

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

   421

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

   422

			param_value = fp_iterator.default_value();

   423

		  }

   424

   425

		  ADD_PARAM_LIST(param_name, param_value, param_type, fp_iterator.param_direction())

   426

		} /* for(...) */

   427

   428

		if (function_call_param_iterator.next_nf() != NULL) ERROR;

   429

   430

		PARAM_LIST_ITERATOR() {

   431

			if ((PARAM_DIRECTION == function_param_iterator_c::direction_out ||

   432

				 PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&

   433

				PARAM_VALUE != NULL) {

   434

			  has_output_params = true;

   435

			}

   436

		}

   437

   438

	    if (has_output_params)

   439

	      generate_inline(symbol->function_name, return_data_type, param_list);

   440

   441

	    CLEAR_PARAM_LIST()

   442

	  }

   443

	  return NULL;

   444

    }

   445

   446

    void *visit(il_formal_funct_call_c *symbol) {

   447

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

   448

   449

	  if (f_decl != function_symtable.end_value()) {

   450

		DECLARE_PARAM_LIST()

   451

		bool has_output_params = false;

   452

   453

		/* determine the base data type returned by the function being called... */

   454

		search_base_type_c search_base_type;

   455

		symbol_c *return_data_type = (symbol_c *)f_decl->type_name->accept(search_base_type);

   456

		if (NULL == return_data_type) ERROR;

   457

   458

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

   459

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

   460

		 */

   461

   462

		function_param_iterator_c fp_iterator(f_decl);

   463

		identifier_c *param_name;

   464

		function_call_param_iterator_c function_call_param_iterator(symbol);

   465

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

   466

		  symbol_c *param_type = fp_iterator.param_type();

   467

		  if (param_type == NULL) ERROR;

   468

   469

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

   470

   471

   472

		  symbol_c *param_value = NULL;

   473

   474

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

   475

		  if (param_value == NULL)

   476

			param_value = function_call_param_iterator.search_f(param_name);

   477

   478

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

   479

		  /* NOTE: the following line of code is not required in this case, but it doesn't

   480

		   * harm to leave it in, as in the case of a formal syntax function call,

   481

		   * it will always return NULL.

   482

		   * We leave it in in case we later decide to merge this part of the code together

   483

		   * with the function calling code in generate_c_st_c, which does require

   484

		   * the following line...

   485

		   */

   486

		  if (param_value == NULL) {

   487

            param_value = function_call_param_iterator.next_nf();

   488

            if (param_value != NULL && fp_iterator.is_en_eno_param_implicit()) ERROR;

   489

          }

   490

   491

		  if (param_value == NULL) {

   492

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

   493

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

   494

			param_value = fp_iterator.default_value();

   495

		  }

   496

   497

		  ADD_PARAM_LIST(param_name, param_value, param_type, fp_iterator.param_direction())

   498

		}

   499

   500

		if (function_call_param_iterator.next_nf() != NULL) ERROR;

   501

   502

		PARAM_LIST_ITERATOR() {

   503

      	  if ((PARAM_DIRECTION == function_param_iterator_c::direction_out ||

   504

      		   PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&

   505

      	      PARAM_VALUE != NULL) {

   506

      	    has_output_params = true;

   507

      	  }

   508

        }

   509

   510

        if (has_output_params)

   511

	      generate_inline(symbol->function_name, return_data_type, param_list);

   512

   513

        CLEAR_PARAM_LIST()

   514

	  }