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

#include <stdlib.h>

    25

    26

class generate_c_typedecl_c: public generate_c_base_c {

    27

    28

  protected:

    29

    stage4out_c &s4o_incl;

    30

    31

  private:

    32

    symbol_c* current_type_name;

    33

    bool array_is_derived;

    34

    search_base_type_c search_base_type;

    35

    search_constant_type_c search_constant_type;

    36

    37

    generate_c_base_c *basedecl;

    38

    39

  public:

    40

    generate_c_typedecl_c(stage4out_c *s4o_ptr, stage4out_c *s4o_incl_ptr): generate_c_base_c(s4o_ptr), s4o_incl(*s4o_incl_ptr) {

    41

      current_typedefinition = none_td;

    42

      current_basetypedeclaration = none_bd;

    43

      current_type_name = NULL;

    44

      basedecl = new generate_c_base_c(&s4o_incl);

    45

    }

    46

    generate_c_typedecl_c(stage4out_c *s4o_ptr): generate_c_base_c(s4o_ptr), s4o_incl(*s4o_ptr) {

    47

      current_typedefinition = none_td;

    48

      current_basetypedeclaration = none_bd;

    49

      current_type_name = NULL;

    50

      basedecl = new generate_c_base_c(&s4o_incl);

    51

    }

    52

    ~generate_c_typedecl_c(void) {

    53

      delete basedecl;

    54

    }

    55

    56

    typedef enum {

    57

      none_td,

    58

      enumerated_td,

    59

      subrange_td,

    60

      array_td,

    61

      struct_td,

    62

    } typedefinition_t;

    63

    64

    typedefinition_t current_typedefinition;

    65

    66

    typedef enum {

    67

      none_bd,

    68

      subrangebasetype_bd,

    69

      subrangetest_bd,

    70

      arrayderiveddeclaration_bd,

    71

      arraybasetype_bd,

    72

      arraybasetypeincl_bd,

    73

      arraysubrange_bd

    74

    } basetypedeclaration_t;

    75

    76

    basetypedeclaration_t current_basetypedeclaration;

    77

    78

    void *print_list_incl(list_c *list,

    79

         std::string pre_elem_str = "",

    80

         std::string inter_elem_str = "",

    81

         std::string post_elem_str = "",

    82

         visitor_c *visitor = NULL) {

    83

      if (visitor == NULL) visitor = this;

    84

    85

      if (list->n > 0) {

    86

//std::cout << "generate_c_base_c::print_list(n = " << list->n << ")   000\n";

    87

        s4o_incl.print(pre_elem_str);

    88

        list->elements[0]->accept(*visitor);

    89

      }

    90

    91

      for(int i = 1; i < list->n; i++) {

    92

//std::cout << "generate_c_base_c::print_list   " << i << "\n";

    93

        s4o_incl.print(inter_elem_str);

    94

        list->elements[i]->accept(*visitor);

    95

      }

    96

    97

      if (list->n > 0)

    98

        s4o_incl.print(post_elem_str);

    99

   100

      return NULL;

   101

    }

   102

   103

   104

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

   105

/* B 0 - Programming Model */

   106

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

   107

  /* leave for derived classes... */

   108

   109

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

   110

/* B.1 - Common elements */

   111

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

   112

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

   113

/* B 1.1 - Letters, digits and identifiers */

   114

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

   115

  /* done in base class(es) */

   116

   117

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

   118

/* B 1.2 - Constants */

   119

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

   120

  /* originally empty... */

   121

   122

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

   123

/* B 1.2.1 - Numeric Literals */

   124

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

   125

  /* done in base class(es) */

   126

   127

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

   128

/* B.1.2.2   Character Strings */

   129

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

   130

  /* done in base class(es) */

   131

   132

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

   133

/* B 1.2.3 - Time Literals */

   134

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

   135

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

   136

/* B 1.2.3.1 - Duration */

   137

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

   138

  /* done in base class(es) */

   139

   140

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

   141

/* B 1.2.3.2 - Time of day and Date */

   142

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

   143

  /* done in base class(es) */

   144

   145

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

   146

/* B.1.3 - Data types */

   147

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

   148

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

   149

/* B 1.3.1 - Elementary Data Types */

   150

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

   151

  /* done in base class(es) */

   152

   153

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

   154

/* B.1.3.2 - Generic data types */

   155

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

   156

  /* originally empty... */

   157

   158

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

   159

/* B 1.3.3 - Derived data types */

   160

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

   161

/*  subrange_type_name ':' subrange_spec_init */

   162

void *visit(subrange_type_declaration_c *symbol) {

   163

  TRACE("subrange_type_declaration_c");  

   164

   165

  current_typedefinition = subrange_td;

   166

  current_type_name = symbol->subrange_type_name;

   167

   168

  s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   169

  current_type_name->accept(*basedecl);

   170

  s4o_incl.print(",");

   171

  current_basetypedeclaration = subrangebasetype_bd;

   172

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

   173

  current_basetypedeclaration = none_bd;

   174

  s4o_incl.print(")\n");

   175

   176

  current_basetypedeclaration = subrangetest_bd;

   177

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

   178

  current_basetypedeclaration = none_bd;

   179

   180

  current_type_name = NULL;

   181

  current_typedefinition = none_td;

   182

   183

  return NULL;

   184

}

   185

   186

/* subrange_specification ASSIGN signed_integer */

   187

void *visit(subrange_spec_init_c *symbol) {

   188

  TRACE("subrange_spec_init_c");

   189

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

   190

  return NULL;

   191

}

   192

   193

/*  integer_type_name '(' subrange')' */

   194

void *visit(subrange_specification_c *symbol) {

   195

  if (current_typedefinition == subrange_td) {

   196

    switch (current_basetypedeclaration) {

   197

      case subrangebasetype_bd:

   198

        symbol->integer_type_name->accept(*basedecl);

   199

        break;

   200

      case subrangetest_bd:

   201

        if (symbol->subrange != NULL) {

   202

          current_type_name->accept(*this);

   203

          s4o.print(" __CHECK_");

   204

          current_type_name->accept(*this);

   205

          s4o.print("(");

   206

          current_type_name->accept(*this);

   207

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

   208

          s4o.indent_right();

   209

   210

          if (search_base_type.type_is_subrange(symbol->integer_type_name)) {

   211

            s4o.print(s4o.indent_spaces + "value = __CHECK_");

   212

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

   213

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

   214

          }

   215

   216

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

   217

   218

          s4o.indent_left();

   219

          s4o.print("}\n");

   220

        }

   221

        else {

   222

          s4o.print("#define __CHECK_");

   223

          current_type_name->accept(*this);

   224

          s4o.print(" __CHECK_");

   225

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

   226

          s4o.print("\n");

   227

        }

   228

        break;

   229

      default:

   230

        break;

   231

    }

   232

  }

   233

  else {

   234

    symbol->integer_type_name->accept(*basedecl);

   235

  }

   236

  return NULL;

   237

}

   238

   239

/*  signed_integer DOTDOT signed_integer */

   240

void *visit(subrange_c *symbol) {

   241

  int dimension;

   242

  switch (current_typedefinition) {

   243

    case array_td:

   244

      if (current_basetypedeclaration == arraysubrange_bd) {

   245

        s4o_incl.print("[");

   246

        s4o_incl.print(symbol->dimension);

   247

        s4o_incl.print("]");

   248

      }

   249

      else

   250

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

   251

      break;

   252

    case subrange_td:

   253

      s4o.print(s4o.indent_spaces + "if (value < ");

   254

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

   255

      s4o.print(")\n");

   256

      s4o.indent_right();

   257

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

   258

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

   259

      s4o.print(";\n");

   260

      s4o.indent_left();

   261

      s4o.print(s4o.indent_spaces + "else if (value > ");

   262

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

   263

      s4o.print(")\n");

   264

      s4o.indent_right();

   265

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

   266

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

   267

      s4o.print(";\n");

   268

      s4o.indent_left();

   269

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

   270

      s4o.indent_right();

   271

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

   272

      s4o.indent_left();

   273

    default:

   274

      break;

   275

  }

   276

  return NULL;

   277

}

   278

   279

/*  enumerated_type_name ':' enumerated_spec_init */

   280

void *visit(enumerated_type_declaration_c *symbol) {

   281

  TRACE("enumerated_type_declaration_c");

   282

   283

  current_typedefinition = enumerated_td;

   284

  current_type_name = symbol->enumerated_type_name;

   285

   286

  s4o_incl.print("__DECLARE_ENUMERATED_TYPE(");

   287

  current_type_name->accept(*basedecl);

   288

  s4o_incl.print(",\n");

   289

  s4o_incl.indent_right();

   290

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

   291

  s4o_incl.indent_left();

   292

  s4o_incl.print(")\n");

   293

   294

  current_type_name = NULL;

   295

  current_typedefinition = none_td;

   296

   297

  return NULL;

   298

}

   299

   300

/* enumerated_specification ASSIGN enumerated_value */

   301

void *visit(enumerated_spec_init_c *symbol) {

   302

  TRACE("enumerated_spec_init_c");

   303

  if (current_typedefinition == enumerated_td)

   304

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

   305

  else

   306

    symbol->enumerated_specification->accept(*basedecl);

   307

  return NULL;

   308

}

   309

   310

/* helper symbol for enumerated_specification->enumerated_spec_init */

   311

/* enumerated_value_list ',' enumerated_value */

   312

void *visit(enumerated_value_list_c *symbol) {

   313

  print_list_incl(symbol, s4o_incl.indent_spaces, ",\n"+s4o_incl.indent_spaces, "\n");

   314

  return NULL;

   315

}

   316

   317

/* enumerated_type_name '#' identifier */

   318

void *visit(enumerated_value_c *symbol) {

   319

  symbol_c *value_type;

   320

  if (current_typedefinition == enumerated_td)

   321

    current_type_name->accept(*basedecl);

   322

  else {

   323

    value_type = (symbol_c *)symbol->accept(search_constant_type);

   324

    if (value_type == NULL) ERROR;

   325

   326

    value_type->accept(*basedecl);

   327

  }

   328

  s4o_incl.print("__");

   329

  symbol->value->accept(*basedecl);

   330

  return NULL;

   331

}

   332

   333

/*  identifier ':' array_spec_init */

   334

void *visit(array_type_declaration_c *symbol) {

   335

  TRACE("array_type_declaration_c");

   336

   337

  current_typedefinition = array_td;

   338

  current_type_name = symbol->identifier;

   339

   340

  array_is_derived = false;

   341

  current_basetypedeclaration = arrayderiveddeclaration_bd;

   342

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

   343

  current_basetypedeclaration = none_bd;

   344

   345

  if (array_is_derived)

   346

	s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   347

  else

   348

	s4o_incl.print("__DECLARE_ARRAY_TYPE(");

   349

  current_type_name->accept(*basedecl);

   350

  s4o_incl.print(",");

   351

  current_basetypedeclaration = arraybasetypeincl_bd;

   352

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

   353

  current_basetypedeclaration = none_bd;

   354

  if (!array_is_derived) {

   355

	s4o_incl.print(",");

   356

	current_basetypedeclaration = arraysubrange_bd;

   357

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

   358

	current_basetypedeclaration = none_bd;

   359

  }

   360

  s4o_incl.print(")\n");

   361

   362

  current_type_name = NULL;

   363

  current_typedefinition = none_td;

   364

   365

  return NULL;

   366

}

   367

   368

/* array_specification [ASSIGN array_initialization] */

   369

/* array_initialization may be NULL ! */

   370

void *visit(array_spec_init_c *symbol) {

   371

  TRACE("array_spec_init_c");

   372

   373

  if (current_typedefinition == array_td) {

   374

    switch (current_basetypedeclaration) {

   375

	  case arrayderiveddeclaration_bd:

   376

	    array_is_derived = dynamic_cast<identifier_c *>(symbol->array_specification) != NULL;

   377

	    break;

   378

	  default:

   379

	    if (array_is_derived)

   380

		  symbol->array_specification->accept(*basedecl);

   381

	    else

   382

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

   383

	    break;

   384

    }

   385

  }

   386

  else {

   387

	symbol->array_specification->accept(*basedecl);

   388

  }

   389

  return NULL;

   390

}

   391

   392

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

   393

void *visit(array_specification_c *symbol) {

   394

  switch (current_basetypedeclaration) {

   395

    case arraybasetype_bd:

   396

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

   397

      break;

   398

    case arraybasetypeincl_bd:

   399

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

   400

      break;

   401

    case arraysubrange_bd:

   402

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

   403

      break;

   404

    default:

   405

      break;

   406

  }

   407

  return NULL;

   408

}

   409

   410

/* helper symbol for array_specification */

   411

/* array_subrange_list ',' subrange */

   412

void *visit(array_subrange_list_c *symbol) {

   413

  print_list(symbol);

   414

  return NULL;

   415

}

   416

   417

/*  TYPE type_declaration_list END_TYPE */

   418

void *visit(data_type_declaration_c *symbol) {

   419

  TRACE("data_type_declaration_c");

   420

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

   421

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

   422

  return NULL;

   423

}

   424

   425

/* helper symbol for data_type_declaration */

   426

void *visit(type_declaration_list_c *symbol) {

   427

  TRACE("type_declaration_list_c");

   428

  return print_list_incl(symbol, "", "\n", "\n");

   429

}

   430

   431

/*  simple_type_name ':' simple_spec_init */

   432

void *visit(simple_type_declaration_c *symbol) {

   433

  TRACE("simple_type_declaration_c");

   434

   435

  s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   436

  symbol->simple_type_name->accept(*basedecl);

   437

  s4o_incl.print(",");

   438

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

   439

  s4o_incl.print(")\n");

   440

   441

  if (search_base_type.type_is_subrange(symbol->simple_type_name)) {

   442

	s4o.print("#define __CHECK_");

   443

	current_type_name->accept(*this);

   444

	s4o.print(" __CHECK_");

   445

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

   446

	s4o.print("\n");

   447

  }

   448

   449

  return NULL;

   450

}

   451

   452

/* simple_specification [ASSIGN constant] */

   453

//SYM_REF2(simple_spec_init_c, simple_specification, constant)

   454

// <constant> may be NULL

   455

void *visit(simple_spec_init_c *symbol) {

   456

  TRACE("simple_spec_init_c");

   457

  symbol->simple_specification->accept(*basedecl);

   458

  return NULL;

   459

}

   460

   461

#if 0

   462

/*  subrange_type_name ':' subrange_spec_init */

   463

SYM_REF2(subrange_type_declaration_c, subrange_type_name, subrange_spec_init)

   464

   465

/* subrange_specification ASSIGN signed_integer */

   466

SYM_REF2(subrange_spec_init_c, subrange_specification, signed_integer)

   467

   468

/*  integer_type_name '(' subrange')' */

   469

SYM_REF2(subrange_specification_c, integer_type_name, subrange)

   470

   471

/*  signed_integer DOTDOT signed_integer */

   472

SYM_REF2(subrange_c, lower_limit, upper_limit)

   473

   474

/*  enumerated_type_name ':' enumerated_spec_init */

   475

SYM_REF2(enumerated_type_declaration_c, enumerated_type_name, enumerated_spec_init)

   476

   477

/* enumerated_specification ASSIGN enumerated_value */

   478

SYM_REF2(enumerated_spec_init_c, enumerated_specification, enumerated_value)

   479

   480

/* helper symbol for enumerated_specification->enumerated_spec_init */

   481

/* enumerated_value_list ',' enumerated_value */

   482

SYM_LIST(enumerated_value_list_c)

   483

   484

/* enumerated_type_name '#' identifier */

   485

SYM_REF2(enumerated_value_c, type, value)

   486

   487

/*  identifier ':' array_spec_init */

   488

SYM_REF2(array_type_declaration_c, identifier, array_spec_init)

   489

   490

/* array_specification [ASSIGN array_initialization} */

   491

/* array_initialization may be NULL ! */

   492

SYM_REF2(array_spec_init_c, array_specification, array_initialization)

   493

   494

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

   495

SYM_REF2(array_specification_c, array_subrange_list, non_generic_type_name)

   496

   497

/* helper symbol for array_specification */

   498