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

    generate_c_base_c *basedecl;

    35

    36

  public:

    37

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

    38

      current_typedefinition = none_td;

    39

      current_basetypedeclaration = none_bd;

    40

      current_type_name = NULL;

    41

      basedecl = new generate_c_base_c(&s4o_incl);

    42

    }

    43

    ~generate_c_typedecl_c(void) {

    44

      delete basedecl;

    45

    }

    46

    47

    typedef enum {

    48

      none_td,

    49

      enumerated_td,

    50

      subrange_td,

    51

      array_td,

    52

      struct_td

    53

    } typedefinition_t;

    54

    55

    typedefinition_t current_typedefinition;

    56

    57

    typedef enum {

    58

      none_bd,

    59

      subrangebasetype_bd,

    60

      subrangetest_bd,

    61

      arrayderiveddeclaration_bd,

    62

      arraybasetype_bd,

    63

      arraybasetypeincl_bd,

    64

      arraysubrange_bd

    65

    } basetypedeclaration_t;

    66

    67

    basetypedeclaration_t current_basetypedeclaration;

    68

    69

    void *print_list_incl(list_c *list,

    70

         std::string pre_elem_str = "",

    71

         std::string inter_elem_str = "",

    72

         std::string post_elem_str = "",

    73

         visitor_c *visitor = NULL) {

    74

      if (visitor == NULL) visitor = this;

    75

    76

      if (list->n > 0) {

    77

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

    78

        s4o_incl.print(pre_elem_str);

    79

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

    80

      }

    81

    82

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

    83

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

    84

        s4o_incl.print(inter_elem_str);

    85

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

    86

      }

    87

    88

      if (list->n > 0)

    89

        s4o_incl.print(post_elem_str);

    90

    91

      return NULL;

    92

    }

    93

    94

    95

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

    96

/* B 0 - Programming Model */

    97

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

    98

  /* leave for derived classes... */

    99

   100

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

   101

/* B.1 - Common elements */

   102

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

   103

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

   104

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

   105

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

   106

  /* done in base class(es) */

   107

   108

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

   109

/* B 1.2 - Constants */

   110

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

   111

  /* originally empty... */

   112

   113

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

   114

/* B 1.2.1 - Numeric Literals */

   115

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

   116

  /* done in base class(es) */

   117

   118

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

   119

/* B.1.2.2   Character Strings */

   120

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

   121

  /* done in base class(es) */

   122

   123

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

   124

/* B 1.2.3 - Time Literals */

   125

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

   126

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

   127

/* B 1.2.3.1 - Duration */

   128

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

   129

  /* done in base class(es) */

   130

   131

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

   132

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

   133

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

   134

  /* done in base class(es) */

   135

   136

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

   137

/* B.1.3 - Data types */

   138

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

   139

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

   140

/* B 1.3.1 - Elementary Data Types */

   141

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

   142

  /* done in base class(es) */

   143

   144

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

   145

/* B.1.3.2 - Generic data types */

   146

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

   147

  /* originally empty... */

   148

   149

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

   150

/* B 1.3.3 - Derived data types */

   151

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

   152

/*  subrange_type_name ':' subrange_spec_init */

   153

void *visit(subrange_type_declaration_c *symbol) {

   154

  TRACE("subrange_type_declaration_c");  

   155

   156

  current_typedefinition = subrange_td;

   157

  current_type_name = symbol->subrange_type_name;

   158

   159

  s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   160

  current_type_name->accept(*basedecl);

   161

  s4o_incl.print(",");

   162

  current_basetypedeclaration = subrangebasetype_bd;

   163

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

   164

  current_basetypedeclaration = none_bd;

   165

  s4o_incl.print(")\n");

   166

   167

  current_basetypedeclaration = subrangetest_bd;

   168

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

   169

  current_basetypedeclaration = none_bd;

   170

   171

  current_type_name = NULL;

   172

  current_typedefinition = none_td;

   173

   174

  return NULL;

   175

}

   176

   177

/* subrange_specification ASSIGN signed_integer */

   178

void *visit(subrange_spec_init_c *symbol) {

   179

  TRACE("subrange_spec_init_c");

   180

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

   181

  return NULL;

   182

}

   183

   184

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

   185

void *visit(subrange_specification_c *symbol) {

   186

  TRACE("subrange_specification_c");

   187

  if (current_typedefinition == subrange_td) {

   188

    switch (current_basetypedeclaration) {

   189

      case subrangebasetype_bd:

   190

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

   191

        break;

   192

      case subrangetest_bd:

   193

        if (symbol->subrange != NULL) {

   194

          s4o_incl.print("static inline ");

   195

          current_type_name->accept(*basedecl);

   196

          s4o_incl.print(" __CHECK_");

   197

          current_type_name->accept(*basedecl);

   198

          s4o_incl.print("(");

   199

          current_type_name->accept(*basedecl);

   200

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

   201

          s4o_incl.indent_right();

   202

   203

          /* NOTE: IEC 61131-3 v2 syntax mandates that the integer type name be one of SINT, ..., LINT, USINT, ... ULIT */

   204

          /*       For this reason, the following condition will always be false, and therefore this is a block

   205

           *       of dead code. However, let's not delete it for now. It might come in useful for IEC 61131-3 v3.

   206

           *       For the moment, we just comment it out!

   207

           */

   208

          /*

   209

          if (get_datatype_info_c::is_subrange(symbol->integer_type_name)) {

   210

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

   211

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

   212

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

   213

          }

   214

          */

   215

   216

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

   217

   218

          s4o_incl.indent_left();

   219

          s4o_incl.print("}\n");

   220

        }

   221

        else {

   222

          s4o_incl.print("#define __CHECK_");

   223

          current_type_name->accept(*basedecl);

   224

          s4o_incl.print(" __CHECK_");

   225

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

   226

          s4o_incl.print("\n");

   227

        }

   228

        break;

   229

      default:

   230

        break;

   231

    }

   232

  }

   233

  return NULL;

   234

}

   235

   236

   237

/*  signed_integer DOTDOT signed_integer */

   238

void *visit(subrange_c *symbol) {

   239

  TRACE("subrange_c");

   240

  int dimension;

   241

  switch (current_typedefinition) {

   242

    case array_td:

   243

      if (current_basetypedeclaration == arraysubrange_bd) {

   244

        s4o_incl.print("[");

   245

        s4o_incl.print(symbol->dimension);

   246

        s4o_incl.print("]");

   247

      }

   248

      else

   249

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

   250

      break;

   251

    case subrange_td:

   252

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

   253

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

   254

      s4o_incl.print(")\n");

   255

      s4o_incl.indent_right();

   256

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

   257

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

   258

      s4o_incl.print(";\n");

   259

      s4o_incl.indent_left();

   260

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

   261

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

   262

      s4o_incl.print(")\n");

   263

      s4o_incl.indent_right();

   264

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

   265

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

   266

      s4o_incl.print(";\n");

   267

      s4o_incl.indent_left();

   268

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

   269

      s4o_incl.indent_right();

   270

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

   271

      s4o_incl.indent_left();

   272

    default:

   273

      break;

   274

  }

   275

  return NULL;

   276

}

   277

   278

/*  enumerated_type_name ':' enumerated_spec_init */

   279

void *visit(enumerated_type_declaration_c *symbol) {

   280

  TRACE("enumerated_type_declaration_c");

   281

   282

  current_typedefinition = enumerated_td;

   283

  current_type_name = symbol->enumerated_type_name;

   284

   285

  s4o_incl.print("__DECLARE_ENUMERATED_TYPE(");

   286

  current_type_name->accept(*basedecl);

   287

  s4o_incl.print(",\n");

   288

  s4o_incl.indent_right();

   289

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

   290

  s4o_incl.indent_left();

   291

  s4o_incl.print(")\n");

   292

   293

  current_type_name = NULL;

   294

  current_typedefinition = none_td;

   295

   296

  return NULL;

   297

}

   298

   299

/* enumerated_specification ASSIGN enumerated_value */

   300

void *visit(enumerated_spec_init_c *symbol) {

   301

  TRACE("enumerated_spec_init_c");

   302

  if (current_typedefinition == enumerated_td)

   303

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

   304

  else

   305

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

   306

  return NULL;

   307

}

   308

   309

/* helper symbol for enumerated_specification->enumerated_spec_init */

   310

/* enumerated_value_list ',' enumerated_value */

   311

void *visit(enumerated_value_list_c *symbol) {

   312

  TRACE("enumerated_value_list_c");

   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

/* Handled by generate_c_base_c class!!

   319

void *visit(enumerated_value_c *symbol) {}

   320

*/

   321

   322

/*  identifier ':' array_spec_init */

   323

void *visit(array_type_declaration_c *symbol) {

   324

  TRACE("array_type_declaration_c");

   325

   326

  current_typedefinition = array_td;

   327

  current_type_name = symbol->identifier;

   328

   329

  array_is_derived = false;

   330

  current_basetypedeclaration = arrayderiveddeclaration_bd;

   331

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

   332

  current_basetypedeclaration = none_bd;

   333

   334

  if (array_is_derived)

   335

    s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   336

  else

   337

    s4o_incl.print("__DECLARE_ARRAY_TYPE(");

   338

  current_type_name->accept(*basedecl);

   339

  s4o_incl.print(",");

   340

  current_basetypedeclaration = arraybasetypeincl_bd;

   341

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

   342

  current_basetypedeclaration = none_bd;

   343

  if (!array_is_derived) {

   344

    s4o_incl.print(",");

   345

    current_basetypedeclaration = arraysubrange_bd;

   346

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

   347

    current_basetypedeclaration = none_bd;

   348

  }

   349

  s4o_incl.print(")\n");

   350

   351

  current_type_name = NULL;

   352

  current_typedefinition = none_td;

   353

   354

  return NULL;

   355

}

   356

   357

/* array_specification [ASSIGN array_initialization] */

   358

/* array_initialization may be NULL ! */

   359

void *visit(array_spec_init_c *symbol) {

   360

  TRACE("array_spec_init_c");

   361

   362

  if (current_typedefinition == array_td) {

   363

    switch (current_basetypedeclaration) {

   364

      case arrayderiveddeclaration_bd:

   365

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

   366

        break;

   367

      default:

   368

        if (array_is_derived)

   369

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

   370

        else

   371

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

   372

        break;

   373

    }

   374

  }

   375

  else {

   376

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

   377

  }

   378

  return NULL;

   379

}

   380

   381

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

   382

void *visit(array_specification_c *symbol) {

   383

  TRACE("array_specification_c");

   384

  switch (current_basetypedeclaration) {

   385

    case arraybasetype_bd:

   386

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

   387

      break;

   388

    case arraybasetypeincl_bd:

   389

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

   390

      break;

   391

    case arraysubrange_bd:

   392

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

   393

      break;

   394

    default:

   395

      break;

   396

  }

   397

  return NULL;

   398

}

   399

   400

   401

/*  TYPE type_declaration_list END_TYPE */

   402

void *visit(data_type_declaration_c *symbol) {

   403

  TRACE("data_type_declaration_c");

   404

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

   405

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

   406

  return NULL;

   407

}

   408

   409

/* helper symbol for data_type_declaration */

   410

void *visit(type_declaration_list_c *symbol) {

   411

  TRACE("type_declaration_list_c");

   412

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

   413

}

   414

   415

/*  simple_type_name ':' simple_spec_init */

   416

void *visit(simple_type_declaration_c *symbol) {

   417

  TRACE("simple_type_declaration_c");

   418

   419

  s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   420

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

   421

  s4o_incl.print(",");

   422

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

   423

  s4o_incl.print(")\n");

   424

   425

  if (get_datatype_info_c::is_subrange(symbol->simple_type_name)) {

   426

    s4o_incl.print("#define __CHECK_");

   427

    current_type_name->accept(*basedecl);

   428

    s4o_incl.print(" __CHECK_");

   429

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

   430

    s4o_incl.print("\n");

   431

  }

   432

   433

  return NULL;

   434

}

   435

   436

/* simple_specification [ASSIGN constant] */

   437

//SYM_REF2(simple_spec_init_c, simple_specification, constant)

   438

// <constant> may be NULL

   439

void *visit(simple_spec_init_c *symbol) {

   440

  TRACE("simple_spec_init_c");

   441

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

   442

  return NULL;

   443

}

   444

   445

#if 0

   446

/*  subrange_type_name ':' subrange_spec_init */

   447

SYM_REF2(subrange_type_declaration_c, subrange_type_name, subrange_spec_init)

   448

   449

/* subrange_specification ASSIGN signed_integer */

   450

SYM_REF2(subrange_spec_init_c, subrange_specification, signed_integer)

   451

   452

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

   453

SYM_REF2(subrange_specification_c, integer_type_name, subrange)

   454

   455

/*  signed_integer DOTDOT signed_integer */

   456

SYM_REF2(subrange_c, lower_limit, upper_limit)

   457

   458

/*  enumerated_type_name ':' enumerated_spec_init */

   459

SYM_REF2(enumerated_type_declaration_c, enumerated_type_name, enumerated_spec_init)

   460

   461

/* enumerated_specification ASSIGN enumerated_value */

   462

SYM_REF2(enumerated_spec_init_c, enumerated_specification, enumerated_value)

   463

   464

/* helper symbol for enumerated_specification->enumerated_spec_init */

   465

/* enumerated_value_list ',' enumerated_value */

   466

SYM_LIST(enumerated_value_list_c)

   467

   468

/* enumerated_type_name '#' identifier */

   469

SYM_REF2(enumerated_value_c, type, value)

   470

   471

/*  identifier ':' array_spec_init */

   472

SYM_REF2(array_type_declaration_c, identifier, array_spec_init)

   473

   474

/* array_specification [ASSIGN array_initialization} */

   475

/* array_initialization may be NULL ! */

   476

SYM_REF2(array_spec_init_c, array_specification, array_initialization)

   477

   478

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

   479

SYM_REF2(array_specification_c, array_subrange_list, non_generic_type_name)

   480

   481

/* helper symbol for array_specification */

   482

/* array_subrange_list ',' subrange */

   483

SYM_LIST(array_subrange_list_c)

   484

   485

/* array_initialization:  '[' array_initial_elements_list ']' */

   486

/* helper symbol for array_initialization */

   487

/* array_initial_elements_list ',' array_initial_elements */

   488

SYM_LIST(array_initial_elements_list_c)

   489

   490

/* integer '(' [array_initial_element] ')' */

   491

/* array_initial_element may be NULL ! */

   492

SYM_REF2(array_initial_elements_c, integer, array_initial_element)

   493

#endif

   494

   495

/*  structure_type_name ':' structure_specification */

   496

//SYM_REF2(structure_type_declaration_c, structure_type_name, structure_specification)

   497

void *visit(structure_type_declaration_c *symbol) {