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,

    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

    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);

   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

   233

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

   234

    /* B 1.4 - Variables */

   235

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

   236

    void *visit(symbolic_variable_c *symbol) {

   244

	    if (vartype == search_var_instance_decl_c::external_vt) {

   245

		  s4o.print(GET_EXTERNAL);

   246

		  s4o.print("(");

   247

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

   248

	    }

   249

	    else {

   250

		  if (vartype == search_var_instance_decl_c::located_vt)

   251

		    s4o.print(GET_LOCATED);

   252

		  else

   253

		    s4o.print(GET_VAR);

   254

		  s4o.print("(");

   255

		  generate_c_base_c::visit(symbol);

   256

	    }

   257

	    s4o.print(")");

   258

      }

   259

      else

   260

        generate_c_base_c::visit(symbol);

   261

      return NULL;

   262

    }

   263

   264

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

   265

    /* B.1.4.1   Directly Represented Variables */

   266

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

   267

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

   268

    void *visit(direct_variable_c *symbol) {

   269

      TRACE("direct_variable_c");

   270

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

   271

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

   272

      s4o.print(GET_LOCATED);

   273

      s4o.print("(");

   274

      this->print_variable_prefix();

   275

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

   276

      s4o.print(")");

   277

      return NULL;

   278

    }

   279

   340

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

   341

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

   342

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

   343

   344

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

   345

    /* B 2.1 Instructions and Operands */

   346

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

   347

   348

    void *visit(il_function_call_c *symbol) {

   349

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

   350

   351

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

   352

		DECLARE_PARAM_LIST()

   353

		bool has_output_params = false;

   354

   355

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

   356

		search_base_type_c search_base_type;

   357

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

   358

		if (NULL == return_data_type) ERROR;

   359

   360

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

   361

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

   362

		 */

   363

   364

		function_param_iterator_c fp_iterator(f_decl);

   365

		identifier_c *param_name;

   366

		function_call_param_iterator_c function_call_param_iterator(symbol);

   367

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

   368

		  symbol_c *param_type = fp_iterator.param_type();

   369

		  if (param_type == NULL) ERROR;

   370

   371

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

   372

   373

		  symbol_c *param_value = NULL;

   374

   375

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

   376

		   * get the value off the IL default variable!

   377

		   */

   378

		 if (1 == i)

   379

		   param_value = &this->default_variable_name;

   380

   381

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

   382

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

   383

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

   384

		   * it will always return NULL.

   385

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

   386

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

   387

		   * the following line...

   388

		   */

   389

		  if (param_value == NULL)

   390

			param_value = function_call_param_iterator.search_f(param_name);

   391

   392

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

   393

		  if (param_value == NULL)

   394

			param_value = function_call_param_iterator.next_nf();

   395

   396

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

   397

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

   398

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

   399

			param_value = fp_iterator.default_value();

   400

		  }

   401

   402

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

   403

		} /* for(...) */

   404

   405

		PARAM_LIST_ITERATOR() {

   406

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

   407

				 PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&

   408

				PARAM_VALUE != NULL) {

   409

			  has_output_params = true;

   410

			}

   411

		}

   412

   413

	    if (has_output_params)

   414

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

   415

   416

	    CLEAR_PARAM_LIST()

   417

	  }

   418

	  return NULL;

   419

    }

   420

   421

    void *visit(il_formal_funct_call_c *symbol) {

   422

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

   423

   424

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

   425

		DECLARE_PARAM_LIST()

   426

		bool has_output_params = false;

   427

   428

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

   429

		search_base_type_c search_base_type;

   430

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

   431

		if (NULL == return_data_type) ERROR;

   432

   433

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

   434

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

   435

		 */

   436

   437

		function_param_iterator_c fp_iterator(f_decl);

   438

		identifier_c *param_name;

   439

		function_call_param_iterator_c function_call_param_iterator(symbol);

   440

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

   441

		  symbol_c *param_type = fp_iterator.param_type();

   442

		  if (param_type == NULL) ERROR;

   443

   444

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

   445

   446

   447

		  symbol_c *param_value = NULL;

   448

   449

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

   450

		  if (param_value == NULL)

   451

			param_value = function_call_param_iterator.search_f(param_name);

   452

   453

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

   454

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

   455

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

   456

		   * it will always return NULL.

   457

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

   458

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

   459

		   * the following line...

   460

		   */

   461

		  if (param_value == NULL)

   462

			param_value = function_call_param_iterator.next_nf();

   463

   464

		  if (param_value == NULL) {

   465

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

   466

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

   467

			param_value = fp_iterator.default_value();

   468

		  }

   469

   470

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

   471

		}

   472

   473

		PARAM_LIST_ITERATOR() {

   474

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

   475

      		   PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&

   476

      	      PARAM_VALUE != NULL) {

   477

      	    has_output_params = true;

   478

      	  }

   479

        }

   480

   481

        if (has_output_params)

   482

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

   483

   484

        CLEAR_PARAM_LIST()

   485

	  }

   486

      return NULL;

   487

    }

   488

   489

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

   490

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

   491

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

   492

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

   493

    /* B 3.1 - Expressions */

   494

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

   495

   496

    void *visit(function_invocation_c *symbol) {

   497

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

   498

   499

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

   500

    	DECLARE_PARAM_LIST()

   501

    	bool has_output_params = false;

   502

   503

    	symbol_c *parameter_assignment_list = NULL;

   504

	    if (NULL != symbol->   formal_param_list) parameter_assignment_list = symbol->   formal_param_list;

   505

	    if (NULL != symbol->nonformal_param_list) parameter_assignment_list = symbol->nonformal_param_list;

   506

	    if (NULL == parameter_assignment_list) ERROR;

   507

   508

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

   509

		search_base_type_c search_base_type;

   510

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

   511

		if (NULL == return_data_type) ERROR;

   512

   513

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

   514

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

   515

         */

   516

        function_param_iterator_c fp_iterator(f_decl);

   517

        identifier_c *param_name;

   518

        function_call_param_iterator_c function_call_param_iterator(symbol);