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

    35

class generate_c_inline_c: public generate_c_typedecl_c {

    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:

    69

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

    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

    81

    virtual ~generate_c_inline_c(void) {

    82

      delete search_varfb_instance_type;

    83

    }

    84

    85

    void *generate_inline(symbol_c *function_name,

    86

    		symbol_c *return_data_type,

    87

    		std::list<FUNCTION_PARAM*> param_list) {

    88

      std::list<FUNCTION_PARAM*>::iterator pt;

    89

    90

      fcall_number++;

    91

    92

      s4o.print(s4o.indent_spaces);

    93

      s4o.print("inline ");

    94

      return_data_type->accept(*this);

    95

      s4o.print(" __");

    96

      fbname->accept(*this);

    97

      s4o.print("_");

    98

      function_name->accept(*this);

    99

      s4o.print_integer(fcall_number);

   100

      s4o.print("(");

   101

      s4o.indent_right();

   102

   103

      PARAM_LIST_ITERATOR() {

   104

        if (PARAM_DIRECTION == function_param_iterator_c::direction_in) {

   105

          PARAM_TYPE->accept(*this);

   106

          s4o.print(" ");

   107

          PARAM_NAME->accept(*this);

   108

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

   109

        }

   110

      }

   111

      fbname->accept(*this);

   112

	  s4o.print(" *");

   113

	  s4o.print(FB_FUNCTION_PARAM);

   114

	  s4o.indent_left();

   115

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

   116

	  s4o.print("{\n");

   117

      s4o.indent_right();

   118

   119

      s4o.print(s4o.indent_spaces);

   120

      return_data_type->accept(*this);

   121

      s4o.print(" "),

   122

      s4o.print(INLINE_RESULT_TEMP_VAR);

   123

      s4o.print(";\n");

   124

   125

	  PARAM_LIST_ITERATOR() {

   126

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

   127

		     PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&

   128

		    PARAM_VALUE != NULL) {

   129

		  s4o.print(s4o.indent_spaces);

   130

		  PARAM_TYPE->accept(*this);

   131

          s4o.print(" ");

   132

          s4o.print(TEMP_VAR);

   133

          PARAM_NAME->accept(*this);

   134

          s4o.print(" = ");

   135

          print_check_function(PARAM_TYPE, PARAM_VALUE);

   136

          s4o.print(";\n");

   137

		}

   138

	  }

   139

   140

	  s4o.print(s4o.indent_spaces + INLINE_RESULT_TEMP_VAR),

   141

			  s4o.print(" = ");

   142

	  function_name->accept(*this);

   143

	  s4o.print("(");

   144

	  s4o.indent_right();

   145

   146

	  PARAM_LIST_ITERATOR() {

   147

		if (pt != param_list.begin())

   148

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

   149

		if (PARAM_DIRECTION == function_param_iterator_c::direction_in)

   150

		  PARAM_NAME->accept(*this);

   151

		else if (PARAM_VALUE != NULL){

   152

          s4o.print("&");

   153

          s4o.print(TEMP_VAR);

   154

          PARAM_NAME->accept(*this);

   155

        }

   156

		else {

   157

		  s4o.print("NULL");

   158

		}

   159

	  }

   160

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

   161

	  s4o.indent_left();

   162

   163

	  PARAM_LIST_ITERATOR() {

   164

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

   165

        	 PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&

   166

        	PARAM_VALUE != NULL) {

   167

   168

          s4o.print(s4o.indent_spaces);

   169

          print_setter(PARAM_VALUE, PARAM_TYPE, PARAM_NAME);

   170

          s4o.print(";\n");

   171

		}

   172

	  }

   173

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

   174

	  s4o.print(INLINE_RESULT_TEMP_VAR);

   175

	  s4o.print(";\n");

   176

   177

      s4o.indent_left();

   178

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

   179

   180

      return NULL;

   181

    }

   182

   183

  private:

   184

   185

    void *print_getter(symbol_c *symbol) {

   186

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

   187

      if (vartype == search_var_instance_decl_c::external_vt)

   188

    	s4o.print(GET_EXTERNAL);

   189

      else if (vartype == search_var_instance_decl_c::located_vt)

   190

    	s4o.print(GET_LOCATED);

   191

      else

   192

    	s4o.print(GET_VAR);

   193

      s4o.print("(");

   194

   195

      wanted_variablegeneration = complextype_base_vg;

   196

      symbol->accept(*this);

   197

      if (search_varfb_instance_type->type_is_complex())

   198

    	s4o.print(",");

   199

      wanted_variablegeneration = complextype_suffix_vg;

   200

      symbol->accept(*this);

   201

      s4o.print(")");

   202

      wanted_variablegeneration = expression_vg;

   203

      return NULL;

   204

    }

   205

   206

    void *print_setter(symbol_c* symbol,

   207

    		symbol_c* type,

   208

    		symbol_c* value) {

   209

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

   231

   232

      wanted_variablegeneration = complextype_base_vg;

   233

      symbol->accept(*this);

   234

      s4o.print(",");

   235

      wanted_variablegeneration = expression_vg;

   236

      print_check_function(type, value, NULL, true);

   237

      if (search_varfb_instance_type->type_is_complex()) {

   238

        s4o.print(",");

   239

        wanted_variablegeneration = complextype_suffix_vg;

   240

        symbol->accept(*this);

   241

      }

   242

      s4o.print(")");

   243

      wanted_variablegeneration = expression_vg;

   244

      return NULL;

   245

    }

   246

   247

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

   248

    /* B 1.4 - Variables */

   249

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

   250

    void *visit(symbolic_variable_c *symbol) {

   251

      unsigned int vartype;

   252

      if (wanted_variablegeneration == complextype_base_vg)

   253

        generate_c_base_c::visit(symbol);

   254

      else if (wanted_variablegeneration == complextype_suffix_vg)

   255

        return NULL;

   256

      else if (wanted_variablegeneration == expression_vg) {

   257

	    vartype = search_varfb_instance_type->get_vartype(symbol);

   258

	    if (vartype == search_var_instance_decl_c::external_vt) {

   259

		  s4o.print(GET_EXTERNAL);

   260

		  s4o.print("(");

   261

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

   262

	    }

   263

	    else {

   264

		  if (vartype == search_var_instance_decl_c::located_vt)

   265

		    s4o.print(GET_LOCATED);

   266

		  else

   267

		    s4o.print(GET_VAR);

   268

		  s4o.print("(");

   269

		  generate_c_base_c::visit(symbol);

   270

	    }

   271

	    s4o.print(")");

   272

      }

   273

      else

   274

        generate_c_base_c::visit(symbol);

   275

      return NULL;

   276

    }

   277

   278

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

   279

    /* B.1.4.1   Directly Represented Variables */

   280

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

   281

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

   282

    void *visit(direct_variable_c *symbol) {

   283

      TRACE("direct_variable_c");

   284

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

   285

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

   286

      s4o.print(GET_LOCATED);

   287

      s4o.print("(");

   288

      this->print_variable_prefix();

   289

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

   290

      s4o.print(")");

   291

      return NULL;

   292

    }

   293

   294

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

   295

    /* B.1.4.2   Multi-element Variables */

   296

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

   297

   298

    // SYM_REF2(structured_variable_c, record_variable, field_selector)

   299

    void *visit(structured_variable_c *symbol) {

   300

      TRACE("structured_variable_c");

   301

      switch (wanted_variablegeneration) {

   302

        case complextype_base_vg:

   303

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

   304

          break;

   305

        case complextype_suffix_vg:

   306

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

   307

          s4o.print(".");

   308

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

   309

          break;

   310

        default:

   311

          if (this->is_variable_prefix_null()) {

   312

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

   313

        	s4o.print(".");

   314

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

   315

          }

   316

          else

   317

        	print_getter(symbol);

   318

          break;

   319

      }

   320

      return NULL;

   321

    }

   322

   323

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

   324

    //SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   325

    void *visit(array_variable_c *symbol) {

   326

      switch (wanted_variablegeneration) {

   327

        case complextype_base_vg:

   328

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

   329

          break;

   330

        case complextype_suffix_vg:

   331

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

   332

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

   333

          if (current_array_type != NULL) {

   334

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

   335

            current_array_type = NULL;

   336

          }

   337

          break;

   338

        default:

   339

          if (this->is_variable_prefix_null()) {

   340

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

   341

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

   342

        	if (current_array_type != NULL) {

   343

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

   344

        	  current_array_type = NULL;

   345

        	}

   346

          }

   347

          else

   348

        	print_getter(symbol);

   349

          break;

   350

      }

   351

      return NULL;

   352

    }

   353

   354

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

   355

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

   356

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

   357

   358

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

   359

    /* B 2.1 Instructions and Operands */

   360

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

   361

   362

    void *visit(il_function_call_c *symbol) {

   363

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

   364

   365

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

   366

		DECLARE_PARAM_LIST()

   367

		bool has_output_params = false;

   368

   369

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

   370

		search_base_type_c search_base_type;

   371

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

   372

		if (NULL == return_data_type) ERROR;

   373

   374

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

   375

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

   376

		 */

   377

   378

		function_param_iterator_c fp_iterator(f_decl);

   379

		identifier_c *param_name;

   380

		function_call_param_iterator_c function_call_param_iterator(symbol);

   381

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

   382

		  symbol_c *param_type = fp_iterator.param_type();

   383

		  if (param_type == NULL) ERROR;

   384

   385

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

   386

   387

		  symbol_c *param_value = NULL;

   388

   389

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

   390

		   * get the value off the IL default variable!

   391

		   */

   392

		 if (1 == i)

   393

		   param_value = &this->default_variable_name;

   394

   395

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

   396

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

   397

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

   398

		   * it will always return NULL.

   399

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

   400

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

   401

		   * the following line...

   402

		   */

   403

		  if (param_value == NULL)

   404

			param_value = function_call_param_iterator.search_f(param_name);

   405

   406

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

   407

		  if (param_value == NULL)

   408

			param_value = function_call_param_iterator.next_nf();

   409

   410

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

   411

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

   412

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

   413

			param_value = fp_iterator.default_value();

   414

		  }

   415

   416

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

   417

		} /* for(...) */

   418

   419

		PARAM_LIST_ITERATOR() {

   420

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

   421

				 PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&

   422

				PARAM_VALUE != NULL) {

   423

			  has_output_params = true;

   424

			}

   425

		}

   426

   427

	    if (has_output_params)

   428

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

   429

   430

	    CLEAR_PARAM_LIST()

   431

	  }

   432

	  return NULL;

   433

    }

   434

   435

    void *visit(il_formal_funct_call_c *symbol) {

   436

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

   437

   438

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

   439

		DECLARE_PARAM_LIST()

   440

		bool has_output_params = false;

   441

   442

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

   443

		search_base_type_c search_base_type;

   444

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

   445

		if (NULL == return_data_type) ERROR;

   446

   447

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

   448

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

   449

		 */

   450

   451

		function_param_iterator_c fp_iterator(f_decl);

   452

		identifier_c *param_name;

   453

		function_call_param_iterator_c function_call_param_iterator(symbol);

   454

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

   455

		  symbol_c *param_type = fp_iterator.param_type();

   456

		  if (param_type == NULL) ERROR;

   457

   458

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

   459

   460

   461

		  symbol_c *param_value = NULL;

   462

   463

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

   464

		  if (param_value == NULL)

   465

			param_value = function_call_param_iterator.search_f(param_name);

   466

   467

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

   468

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

   469

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

   470

		   * it will always return NULL.

   471

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

   472

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

   473

		   * the following line...

   474

		   */

   475

		  if (param_value == NULL)

   476

			param_value = function_call_param_iterator.next_nf();

   477

   478

		  if (param_value == NULL) {

   479

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

   480

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

   481

			param_value = fp_iterator.default_value();

   482

		  }

   483

   484

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

   485

		}

   486

   487

		PARAM_LIST_ITERATOR() {

   488

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

   489

      		   PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&

   490

      	      PARAM_VALUE != NULL) {

   491

      	    has_output_params = true;

   492

      	  }

   493

        }

   494

   495

        if (has_output_params)

   496

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

   497

   498

        CLEAR_PARAM_LIST()

   499

	  }

   500

      return NULL;

   501

    }

   502

   503

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

   504

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

   505

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

   506

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

   507

    /* B 3.1 - Expressions */

   508

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

   509

   510

    void *visit(function_invocation_c *symbol) {

   511

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

   512

   513

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

   514

    	DECLARE_PARAM_LIST()

   515

    	bool has_output_params = false;

   516

   517

    	symbol_c *parameter_assignment_list = NULL;