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

      arraysubrange_bd

    62

    } basetypedeclaration_t;

    63

    64

    basetypedeclaration_t current_basetypedeclaration;

    65

    66

    void *print_list_incl(list_c *list,

    67

         std::string pre_elem_str = "",

    68

         std::string inter_elem_str = "",

    69

         std::string post_elem_str = "",

    70

         visitor_c *visitor = NULL) {

    71

      if (visitor == NULL) visitor = this;

    72

    73

      if (list->n > 0) {

    74

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

    75

        s4o_incl.print(pre_elem_str);

    76

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

    77

      }

    78

    79

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

    80

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

    81

        s4o_incl.print(inter_elem_str);

    82

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

    83

      }

    84

    85

      if (list->n > 0)

    86

        s4o_incl.print(post_elem_str);

    87

    88

      return NULL;

    89

    }

    90

    91

    92

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

    93

/* B 0 - Programming Model */

    94

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

    95

  /* leave for derived classes... */

    96

    97

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

    98

/* B.1 - Common elements */

    99

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

   100

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

   101

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

   102

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

   103

  /* done in base class(es) */

   104

   105

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

   106

/* B 1.2 - Constants */

   107

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

   108

  /* originally empty... */

   109

   110

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

   111

/* B 1.2.1 - Numeric Literals */

   112

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

   113

  /* done in base class(es) */

   114

   115

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

   116

/* B.1.2.2   Character Strings */

   117

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

   118

  /* done in base class(es) */

   119

   120

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

   121

/* B 1.2.3 - Time Literals */

   122

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

   123

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

   124

/* B 1.2.3.1 - Duration */

   125

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

   126

  /* done in base class(es) */

   127

   128

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

   129

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

   130

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

   131

  /* done in base class(es) */

   132

   133

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

   134

/* B.1.3 - Data types */

   135

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

   136

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

   137

/* B 1.3.1 - Elementary Data Types */

   138

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

   139

  /* done in base class(es) */

   140

   141

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

   142

/* B.1.3.2 - Generic data types */

   143

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

   144

  /* originally empty... */

   145

   146

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

   147

/* B 1.3.3 - Derived data types */

   148

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

   149

/*  subrange_type_name ':' subrange_spec_init */

   150

void *visit(subrange_type_declaration_c *symbol) {

   151

  TRACE("subrange_type_declaration_c");  

   152

   153

  current_typedefinition = subrange_td;

   154

  current_type_name = symbol->subrange_type_name;

   155

   156

  s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   157

  current_type_name->accept(*basedecl);

   158

  s4o_incl.print(",");

   159

  current_basetypedeclaration = subrangebasetype_bd;

   160

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

   161

  current_basetypedeclaration = none_bd;

   162

  s4o_incl.print(")\n");

   163

   164

  current_basetypedeclaration = subrangetest_bd;

   165

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

   166

  current_basetypedeclaration = none_bd;

   167

   168

  current_type_name = NULL;

   169

  current_typedefinition = none_td;

   170

   171

  return NULL;

   172

}

   173

   174

/* subrange_specification ASSIGN signed_integer */

   175

void *visit(subrange_spec_init_c *symbol) {

   176

  TRACE("subrange_spec_init_c");

   177

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

   178

  return NULL;

   179

}

   180

   181

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

   182

void *visit(subrange_specification_c *symbol) {

   183

  TRACE("subrange_specification_c");

   184

  if (current_typedefinition == subrange_td) {

   185

    switch (current_basetypedeclaration) {

   186

      case subrangebasetype_bd:

   187

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

   188

        break;

   189

      case subrangetest_bd:

   190

        if (symbol->subrange != NULL) {

   191

          s4o_incl.print("static inline ");

   192

          current_type_name->accept(*basedecl);

   193

          s4o_incl.print(" __CHECK_");

   194

          current_type_name->accept(*basedecl);

   195

          s4o_incl.print("(");

   196

          current_type_name->accept(*basedecl);

   197

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

   198

          s4o_incl.indent_right();

   199

   200

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

   201

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

   202

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

   203

           *       For the moment, we just comment it out!

   204

           */

   205

          /*

   206

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

   207

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

   208

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

   209

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

   210

          }

   211

          */

   212

   213

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

   214

   215

          s4o_incl.indent_left();

   216

          s4o_incl.print("}\n");

   217

        }

   218

        else {

   219

          s4o_incl.print("#define __CHECK_");

   220

          current_type_name->accept(*basedecl);

   221

          s4o_incl.print(" __CHECK_");

   222

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

   223

          s4o_incl.print("\n");

   224

        }

   225

        break;

   226

      default:

   227

        break;

   228

    }

   229

  }

   230

  return NULL;

   231

}

   232

   233

   234

/*  signed_integer DOTDOT signed_integer */

   235

void *visit(subrange_c *symbol) {

   236

  TRACE("subrange_c");

   237

  int dimension;

   238

  switch (current_typedefinition) {

   239

    case array_td:

   240

      if (current_basetypedeclaration == arraysubrange_bd) {

   241

        s4o_incl.print("[");

   242

        s4o_incl.print(symbol->dimension);

   243

        s4o_incl.print("]");

   244

      }

   245

      else

   246

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

   247

      break;

   248

    case subrange_td:

   249

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

   250

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

   251

      s4o_incl.print(")\n");

   252

      s4o_incl.indent_right();

   253

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

   254

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

   255

      s4o_incl.print(";\n");

   256

      s4o_incl.indent_left();

   257

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

   258

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

   259

      s4o_incl.print(")\n");

   260

      s4o_incl.indent_right();

   261

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

   262

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

   263

      s4o_incl.print(";\n");

   264

      s4o_incl.indent_left();

   265

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

   266

      s4o_incl.indent_right();

   267

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

   268

      s4o_incl.indent_left();

   269

    default:

   270

      break;

   271

  }

   272

  return NULL;

   273

}

   274

   275

/*  enumerated_type_name ':' enumerated_spec_init */

   276

void *visit(enumerated_type_declaration_c *symbol) {

   277

  TRACE("enumerated_type_declaration_c");

   278

   279

  current_typedefinition = enumerated_td;

   280

  current_type_name = symbol->enumerated_type_name;

   281

   282

  s4o_incl.print("__DECLARE_ENUMERATED_TYPE(");

   283

  current_type_name->accept(*basedecl);

   284

  s4o_incl.print(",\n");

   285

  s4o_incl.indent_right();

   286

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

   287

  s4o_incl.indent_left();

   288

  s4o_incl.print(")\n");

   289

   290

  current_type_name = NULL;

   291

  current_typedefinition = none_td;

   292

   293

  return NULL;

   294

}

   295

   296

/* enumerated_specification ASSIGN enumerated_value */

   297

void *visit(enumerated_spec_init_c *symbol) {

   298

  TRACE("enumerated_spec_init_c");

   299

  if (current_typedefinition == enumerated_td)

   300

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

   301

  else

   302

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

   303

  return NULL;

   304

}

   305

   306

/* helper symbol for enumerated_specification->enumerated_spec_init */

   307

/* enumerated_value_list ',' enumerated_value */

   308

void *visit(enumerated_value_list_c *symbol) {

   309

  TRACE("enumerated_value_list_c");

   310

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

   311

  return NULL;

   312

}

   313

   314

/* enumerated_type_name '#' identifier */

   315

/* Handled by generate_c_base_c class!!

   316

void *visit(enumerated_value_c *symbol) {}

   317

*/

   318

   319

/*  identifier ':' array_spec_init */

   320

void *visit(array_type_declaration_c *symbol) {

   321

  TRACE("array_type_declaration_c");

   322

  current_typedefinition = array_td;

   323

  current_type_name = symbol->identifier;

   324

   325

  int implicit_id_count = symbol->array_spec_init->anotations_map.count("generate_c_annotaton__implicit_type_id");

   326

  if (implicit_id_count  > 1) ERROR;

   327

  if (implicit_id_count == 1)

   328

    s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   329

  else

   330

    s4o_incl.print("__DECLARE_ARRAY_TYPE(");

   331

  current_type_name->accept(*basedecl);

   332

  s4o_incl.print(",");

   333

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

   334

  s4o_incl.print(")\n");

   335

   336

  current_type_name = NULL;

   337

  current_typedefinition = none_td;

   338

  return NULL;

   339

}

   340

   341

   342

   343

/* array_specification [ASSIGN array_initialization] */

   344

/* array_initialization may be NULL ! */

   345

void *visit(array_spec_init_c *symbol) {

   346

  TRACE("array_spec_init_c");  

   347

  int implicit_id_count = symbol->anotations_map.count("generate_c_annotaton__implicit_type_id");

   348

  if (implicit_id_count  > 1) ERROR;

   349

  if (implicit_id_count == 1) {

   350

      /* this is part of an implicitly declared datatype (i.e. inside a variable decaration), for which an equivalent C datatype

   351

       * has already been defined. So, we simly print out the id of that C datatpe...

   352

       */

   353

    symbol->anotations_map["generate_c_annotaton__implicit_type_id"]->accept(*basedecl);

   354

    return NULL;

   355

  }

   356

//   if (current_typedefinition != array_td) {debug_c::print(symbol); ERROR;}

   357

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

   358

  return NULL;

   359

}

   360

   361

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

   362

void *visit(array_specification_c *symbol) {

   363

  TRACE("array_specification_c");

   364

  int implicit_id_count = symbol->anotations_map.count("generate_c_annotaton__implicit_type_id");

   365

  if (implicit_id_count  > 1) ERROR;

   366

  if (implicit_id_count == 1) {

   367

      /* this is part of an implicitly declared datatype (i.e. inside a variable decaration), for which an equivalent C datatype

   368

       * has already been defined. So, we simly print out the id of that C datatpe...

   369

       */

   370

    symbol->anotations_map["generate_c_annotaton__implicit_type_id"]->accept(*basedecl);

   371

    return NULL;

   372

  }

   373

  // The 2nd and 3rd argument of a call to the __DECLARE_ARRAY_TYPE macro!

   374

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

   375

  s4o_incl.print(",");

   376

  current_basetypedeclaration = arraysubrange_bd;

   377

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

   378

  current_basetypedeclaration = none_bd;

   379

  return NULL;

   380

}

   381

   382

   383

/*  TYPE type_declaration_list END_TYPE */

   384

void *visit(data_type_declaration_c *symbol) {

   385

  TRACE("data_type_declaration_c");

   386

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

   387

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

   388

  return NULL;

   389

}

   390

   391

/* helper symbol for data_type_declaration */

   392

void *visit(type_declaration_list_c *symbol) {

   393

  TRACE("type_declaration_list_c");

   394

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

   395

}

   396

   397

/*  simple_type_name ':' simple_spec_init */

   398

void *visit(simple_type_declaration_c *symbol) {

   399

  TRACE("simple_type_declaration_c");

   400

   401

  s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   402

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

   403

  s4o_incl.print(",");

   404

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

   405

  s4o_incl.print(")\n");

   406

   407

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

   408

    s4o_incl.print("#define __CHECK_");

   409

    current_type_name->accept(*basedecl);

   410

    s4o_incl.print(" __CHECK_");

   411

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

   412

    s4o_incl.print("\n");

   413

  }

   414

   415

  return NULL;

   416

}

   417

   418

/* simple_specification [ASSIGN constant] */

   419

//SYM_REF2(simple_spec_init_c, simple_specification, constant)

   420

// <constant> may be NULL

   421

void *visit(simple_spec_init_c *symbol) {

   422

  TRACE("simple_spec_init_c");

   423

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

   424

  return NULL;

   425

}

   426

   427

#if 0

   428

/*  subrange_type_name ':' subrange_spec_init */

   429

SYM_REF2(subrange_type_declaration_c, subrange_type_name, subrange_spec_init)

   430

   431

/* subrange_specification ASSIGN signed_integer */

   432

SYM_REF2(subrange_spec_init_c, subrange_specification, signed_integer)

   433

   434

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

   435

SYM_REF2(subrange_specification_c, integer_type_name, subrange)

   436

   437

/*  signed_integer DOTDOT signed_integer */

   438

SYM_REF2(subrange_c, lower_limit, upper_limit)

   439

   440

/*  enumerated_type_name ':' enumerated_spec_init */

   441

SYM_REF2(enumerated_type_declaration_c, enumerated_type_name, enumerated_spec_init)

   442

   443

/* enumerated_specification ASSIGN enumerated_value */

   444

SYM_REF2(enumerated_spec_init_c, enumerated_specification, enumerated_value)

   445

   446

/* helper symbol for enumerated_specification->enumerated_spec_init */

   447

/* enumerated_value_list ',' enumerated_value */

   448

SYM_LIST(enumerated_value_list_c)

   449

   450

/* enumerated_type_name '#' identifier */

   451

SYM_REF2(enumerated_value_c, type, value)

   452

   453

/*  identifier ':' array_spec_init */

   454

SYM_REF2(array_type_declaration_c, identifier, array_spec_init)

   455

   456

/* array_specification [ASSIGN array_initialization} */

   457

/* array_initialization may be NULL ! */

   458

SYM_REF2(array_spec_init_c, array_specification, array_initialization)

   459

   460

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

   461

SYM_REF2(array_specification_c, array_subrange_list, non_generic_type_name)

   462

   463

/* helper symbol for array_specification */

   464

/* array_subrange_list ',' subrange */

   465

SYM_LIST(array_subrange_list_c)

   466

   467

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

   468

/* helper symbol for array_initialization */

   469

/* array_initial_elements_list ',' array_initial_elements */

   470

SYM_LIST(array_initial_elements_list_c)

   471

   472

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

   473

/* array_initial_element may be NULL ! */

   474

SYM_REF2(array_initial_elements_c, integer, array_initial_element)

   475

#endif

   476

   477

/*  structure_type_name ':' structure_specification */

   478

//SYM_REF2(structure_type_declaration_c, structure_type_name, structure_specification)

   479

void *visit(structure_type_declaration_c *symbol) {

   480

  TRACE("structure_type_declaration_c");

   481

   482

  current_typedefinition = struct_td;

   483

   484

  s4o_incl.print("__DECLARE_STRUCT_TYPE(");

   485

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

   486

  s4o_incl.print(",");

   487

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

   488

  s4o_incl.print(")\n");

   489

   490

  current_typedefinition = none_td;

   491

   492

  return NULL;

   493

}

   494

   495

/* structure_type_name ASSIGN structure_initialization */

   496

/* structure_initialization may be NULL ! */

   497

//SYM_REF2(initialized_structure_c, structure_type_name, structure_initialization)

   498

void *visit(initialized_structure_c *symbol) {