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

    35

    generate_c_base_c *basedecl;

    36

    37

  public:

    38

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

    39

      current_typedefinition = none_td;

    40

      current_basetypedeclaration = none_bd;

    41

      current_type_name = NULL;

    42

      basedecl = new generate_c_base_c(&s4o_incl);

    43

    }

    44

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

    45

      current_typedefinition = none_td;

    46

      current_basetypedeclaration = none_bd;

    47

      current_type_name = NULL;

    48

      basedecl = new generate_c_base_c(&s4o_incl);

    49

    }

    50

    ~generate_c_typedecl_c(void) {

    51

      delete basedecl;

    52

    }

    53

    54

    typedef enum {

    55

      none_td,

    56

      enumerated_td,

    57

      subrange_td,

    58

      array_td,

    59

      struct_td

    60

    } typedefinition_t;

    61

    62

    typedefinition_t current_typedefinition;

    63

    64

    typedef enum {

    65

      none_bd,

    66

      subrangebasetype_bd,

    67

      subrangetest_bd,

    68

      arrayderiveddeclaration_bd,

    69

      arraybasetype_bd,

    70

      arraybasetypeincl_bd,

    71

      arraysubrange_bd

    72

    } basetypedeclaration_t;

    73

    74

    basetypedeclaration_t current_basetypedeclaration;

    75

    76

    void *print_list_incl(list_c *list,

    77

         std::string pre_elem_str = "",

    78

         std::string inter_elem_str = "",

    79

         std::string post_elem_str = "",

    80

         visitor_c *visitor = NULL) {

    81

      if (visitor == NULL) visitor = this;

    82

    83

      if (list->n > 0) {

    84

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

    85

        s4o_incl.print(pre_elem_str);

    86

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

    87

      }

    88

    89

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

    90

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

    91

        s4o_incl.print(inter_elem_str);

    92

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

    93

      }

    94

    95

      if (list->n > 0)

    96

        s4o_incl.print(post_elem_str);

    97

    98

      return NULL;

    99

    }

   100

   101

   102

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

   103

/* B 0 - Programming Model */

   104

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

   105

  /* leave for derived classes... */

   106

   107

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

   108

/* B.1 - Common elements */

   109

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

   110

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

   111

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

   112

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

   113

  /* done in base class(es) */

   114

   115

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

   116

/* B 1.2 - Constants */

   117

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

   118

  /* originally empty... */

   119

   120

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

   121

/* B 1.2.1 - Numeric Literals */

   122

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

   123

  /* done in base class(es) */

   124

   125

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

   126

/* B.1.2.2   Character Strings */

   127

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

   128

  /* done in base class(es) */

   129

   130

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

   131

/* B 1.2.3 - Time Literals */

   132

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

   133

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

   134

/* B 1.2.3.1 - Duration */

   135

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

   136

  /* done in base class(es) */

   137

   138

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

   139

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

   140

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

   141

  /* done in base class(es) */

   142

   143

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

   144

/* B.1.3 - Data types */

   145

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

   146

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

   147

/* B 1.3.1 - Elementary Data Types */

   148

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

   149

  /* done in base class(es) */

   150

   151

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

   152

/* B.1.3.2 - Generic data types */

   153

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

   154

  /* originally empty... */

   155

   156

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

   157

/* B 1.3.3 - Derived data types */

   158

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

   159

/*  subrange_type_name ':' subrange_spec_init */

   160

void *visit(subrange_type_declaration_c *symbol) {

   161

  TRACE("subrange_type_declaration_c");  

   162

   163

  current_typedefinition = subrange_td;

   164

  current_type_name = symbol->subrange_type_name;

   165

   166

  s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   167

  current_type_name->accept(*basedecl);

   168

  s4o_incl.print(",");

   169

  current_basetypedeclaration = subrangebasetype_bd;

   170

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

   171

  current_basetypedeclaration = none_bd;

   172

  s4o_incl.print(")\n");

   173

   174

  current_basetypedeclaration = subrangetest_bd;

   175

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

   176

  current_basetypedeclaration = none_bd;

   177

   178

  current_type_name = NULL;

   179

  current_typedefinition = none_td;

   180

   181

  return NULL;

   182

}

   183

   184

/* subrange_specification ASSIGN signed_integer */

   185

void *visit(subrange_spec_init_c *symbol) {

   186

  TRACE("subrange_spec_init_c");

   187

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

   188

  return NULL;

   189

}

   190

   191

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

   192

void *visit(subrange_specification_c *symbol) {

   193

  if (current_typedefinition == subrange_td) {

   194

    switch (current_basetypedeclaration) {

   195

      case subrangebasetype_bd:

   196

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

   197

        break;

   198

      case subrangetest_bd:

   199

        if (symbol->subrange != NULL) {

   200

          current_type_name->accept(*this);

   201

          s4o.print(" __CHECK_");

   202

          current_type_name->accept(*this);

   203

          s4o.print("(");

   204

          current_type_name->accept(*this);

   205

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

   206

          s4o.indent_right();

   207

   208

          if (search_base_type_c::type_is_subrange(symbol->integer_type_name)) {

   209

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

   210

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

   211

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

   212

          }

   213

   214

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

   215

   216

          s4o.indent_left();

   217

          s4o.print("}\n");

   218

        }

   219

        else {

   220

          s4o.print("#define __CHECK_");

   221

          current_type_name->accept(*this);

   222

          s4o.print(" __CHECK_");

   223

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

   224

          s4o.print("\n");

   225

        }

   226

        break;

   227

      default:

   228

        break;

   229

    }

   230

  }

   231

  else {

   232

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

   233

  }

   234

  return NULL;

   235

}

   236

   237

/*  signed_integer DOTDOT signed_integer */

   238

void *visit(subrange_c *symbol) {

   239

  int dimension;

   240

  switch (current_typedefinition) {

   241

    case array_td:

   242

      if (current_basetypedeclaration == arraysubrange_bd) {

   243

        s4o_incl.print("[");

   244

        s4o_incl.print(symbol->dimension);

   245

        s4o_incl.print("]");

   246

      }

   247

      else

   248

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

   249

      break;

   250

    case subrange_td:

   251

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

   252

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

   253

      s4o.print(")\n");

   254

      s4o.indent_right();

   255

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

   256

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

   257

      s4o.print(";\n");

   258

      s4o.indent_left();

   259

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

   260

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

   261

      s4o.print(")\n");

   262

      s4o.indent_right();

   263

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

   264

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

   265

      s4o.print(";\n");

   266

      s4o.indent_left();

   267

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

   268

      s4o.indent_right();

   269

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

   270

      s4o.indent_left();

   271

    default:

   272

      break;

   273

  }

   274

  return NULL;

   275

}

   276

   277

/*  enumerated_type_name ':' enumerated_spec_init */

   278

void *visit(enumerated_type_declaration_c *symbol) {

   279

  TRACE("enumerated_type_declaration_c");

   280

   281

  current_typedefinition = enumerated_td;

   282

  current_type_name = symbol->enumerated_type_name;

   283

   284

  s4o_incl.print("__DECLARE_ENUMERATED_TYPE(");

   285

  current_type_name->accept(*basedecl);

   286

  s4o_incl.print(",\n");

   287

  s4o_incl.indent_right();

   288

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

   289

  s4o_incl.indent_left();

   290

  s4o_incl.print(")\n");

   291

   292

  current_type_name = NULL;

   293

  current_typedefinition = none_td;

   294

   295

  return NULL;

   296

}

   297

   298

/* enumerated_specification ASSIGN enumerated_value */

   299

void *visit(enumerated_spec_init_c *symbol) {

   300

  TRACE("enumerated_spec_init_c");

   301

  if (current_typedefinition == enumerated_td)

   302

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

   303

  else

   304

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

   305

  return NULL;

   306

}

   307

   308

/* helper symbol for enumerated_specification->enumerated_spec_init */

   309

/* enumerated_value_list ',' enumerated_value */

   310

void *visit(enumerated_value_list_c *symbol) {

   311

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

   312

  return NULL;

   313

}

   314

   315

/* enumerated_type_name '#' identifier */

   316

void *visit(enumerated_value_c *symbol) {

   317

  if (current_typedefinition == enumerated_td)

   318

    current_type_name->accept(*basedecl);

   319

  else {

   324

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

   325

  }

   326

  s4o_incl.print("__");

   327

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

   328

  return NULL;

   329

}

   330

   331

/*  identifier ':' array_spec_init */

   332

void *visit(array_type_declaration_c *symbol) {

   333

  TRACE("array_type_declaration_c");

   334

   335

  current_typedefinition = array_td;

   336

  current_type_name = symbol->identifier;

   337

   338

  array_is_derived = false;

   339

  current_basetypedeclaration = arrayderiveddeclaration_bd;

   340

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

   341

  current_basetypedeclaration = none_bd;

   342

   343

  if (array_is_derived)

   344

	s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   345

  else

   346

	s4o_incl.print("__DECLARE_ARRAY_TYPE(");

   347

  current_type_name->accept(*basedecl);

   348

  s4o_incl.print(",");

   349

  current_basetypedeclaration = arraybasetypeincl_bd;

   350

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

   351

  current_basetypedeclaration = none_bd;

   352

  if (!array_is_derived) {

   353

	s4o_incl.print(",");

   354

	current_basetypedeclaration = arraysubrange_bd;

   355

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

   356

	current_basetypedeclaration = none_bd;

   357

  }

   358

  s4o_incl.print(")\n");

   359

   360

  current_type_name = NULL;

   361

  current_typedefinition = none_td;

   362

   363

  return NULL;

   364

}

   365

   366

/* array_specification [ASSIGN array_initialization] */

   367

/* array_initialization may be NULL ! */

   368

void *visit(array_spec_init_c *symbol) {

   369

  TRACE("array_spec_init_c");

   370

   371

  if (current_typedefinition == array_td) {

   372

    switch (current_basetypedeclaration) {

   373

	  case arrayderiveddeclaration_bd:

   374

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

   375

	    break;

   376

	  default:

   377

	    if (array_is_derived)

   378

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

   379

	    else

   380

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

   381

	    break;

   382

    }

   383

  }

   384

  else {

   385

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

   386

  }

   387

  return NULL;

   388

}

   389

   390

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

   391

void *visit(array_specification_c *symbol) {

   392

  switch (current_basetypedeclaration) {

   393

    case arraybasetype_bd:

   394

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

   395

      break;

   396

    case arraybasetypeincl_bd:

   397

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

   398

      break;

   399

    case arraysubrange_bd:

   400

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

   401

      break;

   402

    default:

   403

      break;

   404

  }

   405

  return NULL;

   406

}

   407

   408

/* helper symbol for array_specification */

   409

/* array_subrange_list ',' subrange */

   410

void *visit(array_subrange_list_c *symbol) {

   411

  print_list(symbol);

   412

  return NULL;

   413

}

   414

   415

/*  TYPE type_declaration_list END_TYPE */

   416

void *visit(data_type_declaration_c *symbol) {

   417

  TRACE("data_type_declaration_c");

   418

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

   419

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

   420

  return NULL;

   421

}

   422

   423

/* helper symbol for data_type_declaration */

   424

void *visit(type_declaration_list_c *symbol) {

   425

  TRACE("type_declaration_list_c");

   426

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

   427

}

   428

   429

/*  simple_type_name ':' simple_spec_init */

   430

void *visit(simple_type_declaration_c *symbol) {

   431

  TRACE("simple_type_declaration_c");

   432

   433

  s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   434

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

   435

  s4o_incl.print(",");

   436

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

   437

  s4o_incl.print(")\n");

   438

   439

  if (search_base_type_c::type_is_subrange(symbol->simple_type_name)) {

   440

	s4o.print("#define __CHECK_");

   441

	current_type_name->accept(*this);

   442

	s4o.print(" __CHECK_");

   443

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

   444

	s4o.print("\n");

   445

  }

   446

   447

  return NULL;

   448

}

   449

   450

/* simple_specification [ASSIGN constant] */

   451

//SYM_REF2(simple_spec_init_c, simple_specification, constant)

   452

// <constant> may be NULL

   453

void *visit(simple_spec_init_c *symbol) {

   454

  TRACE("simple_spec_init_c");

   455

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

   456

  return NULL;

   457

}

   458

   459

#if 0

   460

/*  subrange_type_name ':' subrange_spec_init */

   461

SYM_REF2(subrange_type_declaration_c, subrange_type_name, subrange_spec_init)

   462

   463

/* subrange_specification ASSIGN signed_integer */

   464

SYM_REF2(subrange_spec_init_c, subrange_specification, signed_integer)

   465

   466

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

   467

SYM_REF2(subrange_specification_c, integer_type_name, subrange)

   468

   469

/*  signed_integer DOTDOT signed_integer */

   470

SYM_REF2(subrange_c, lower_limit, upper_limit)

   471

   472

/*  enumerated_type_name ':' enumerated_spec_init */

   473

SYM_REF2(enumerated_type_declaration_c, enumerated_type_name, enumerated_spec_init)

   474

   475

/* enumerated_specification ASSIGN enumerated_value */

   476

SYM_REF2(enumerated_spec_init_c, enumerated_specification, enumerated_value)

   477

   478

/* helper symbol for enumerated_specification->enumerated_spec_init */

   479

/* enumerated_value_list ',' enumerated_value */

   480

SYM_LIST(enumerated_value_list_c)

   481

   482

/* enumerated_type_name '#' identifier */

   483

SYM_REF2(enumerated_value_c, type, value)

   484

   485

/*  identifier ':' array_spec_init */

   486

SYM_REF2(array_type_declaration_c, identifier, array_spec_init)

   487

   488

/* array_specification [ASSIGN array_initialization} */

   489

/* array_initialization may be NULL ! */

   490

SYM_REF2(array_spec_init_c, array_specification, array_initialization)

   491

   492

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

   493

SYM_REF2(array_specification_c, array_subrange_list, non_generic_type_name)

   494

   495

/* helper symbol for array_specification */

   496

/* array_subrange_list ',' subrange */

   497

SYM_LIST(array_subrange_list_c)

   498