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_integer(unsigned int integer) {

    79

      char str[10];

    80

      sprintf(str, "%d", integer);

    81

      s4o.print(str);

    82

    }

    83

    84

    void print_integer_incl(unsigned int integer) {

    85

      char str[10];

    86

      sprintf(str, "%d", integer);

    87

      s4o_incl.print(str);

    88

    }

    89

    90

    void *print_list_incl(list_c *list,

    91

         std::string pre_elem_str = "",

    92

         std::string inter_elem_str = "",

    93

         std::string post_elem_str = "",

    94

         visitor_c *visitor = NULL) {

    95

      if (visitor == NULL) visitor = this;

    96

    97

      if (list->n > 0) {

    98

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

    99

        s4o_incl.print(pre_elem_str);

   100

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

   101

      }

   102

   103

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

   104

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

   105

        s4o_incl.print(inter_elem_str);

   106

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

   107

      }

   108

   109

      if (list->n > 0)

   110

        s4o_incl.print(post_elem_str);

   111

   112

      return NULL;

   113

    }

   114

   115

   116

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

   117

/* B 0 - Programming Model */

   118

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

   119

  /* leave for derived classes... */

   120

   121

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

   122

/* B.1 - Common elements */

   123

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

   124

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

   125

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

   126

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

   127

  /* done in base class(es) */

   128

   129

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

   130

/* B 1.2 - Constants */

   131

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

   132

  /* originally empty... */

   133

   134

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

   135

/* B 1.2.1 - Numeric Literals */

   136

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

   137

  /* done in base class(es) */

   138

   139

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

   140

/* B.1.2.2   Character Strings */

   141

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

   142

  /* done in base class(es) */

   143

   144

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

   145

/* B 1.2.3 - Time Literals */

   146

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

   147

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

   148

/* B 1.2.3.1 - Duration */

   149

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

   150

  /* done in base class(es) */

   151

   152

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

   153

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

   154

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

   155

  /* done in base class(es) */

   156

   157

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

   158

/* B.1.3 - Data types */

   159

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

   160

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

   161

/* B 1.3.1 - Elementary Data Types */

   162

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

   163

  /* done in base class(es) */

   164

   165

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

   166

/* B.1.3.2 - Generic data types */

   167

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

   168

  /* originally empty... */

   169

   170

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

   171

/* B 1.3.3 - Derived data types */

   172

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

   173

/*  subrange_type_name ':' subrange_spec_init */

   174

void *visit(subrange_type_declaration_c *symbol) {

   175

  TRACE("subrange_type_declaration_c");  

   176

   177

  current_typedefinition = subrange_td;

   178

  current_type_name = symbol->subrange_type_name;

   179

   180

  s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   181

  current_type_name->accept(*basedecl);

   182

  s4o_incl.print(",");

   183

  current_basetypedeclaration = subrangebasetype_bd;

   184

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

   185

  current_basetypedeclaration = none_bd;

   186

  s4o_incl.print(")\n");

   187

   188

  current_basetypedeclaration = subrangetest_bd;

   189

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

   190

  current_basetypedeclaration = none_bd;

   191

   192

  current_type_name = NULL;

   193

  current_typedefinition = none_td;

   194

   195

  return NULL;

   196

}

   197

   198

/* subrange_specification ASSIGN signed_integer */

   199

void *visit(subrange_spec_init_c *symbol) {

   200

  TRACE("subrange_spec_init_c");

   201

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

   202

  return NULL;

   203

}

   204

   205

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

   206

void *visit(subrange_specification_c *symbol) {

   207

  if (current_typedefinition == subrange_td) {

   208

    switch (current_basetypedeclaration) {

   209

      case subrangebasetype_bd:

   210

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

   211

        break;

   212

      case subrangetest_bd:

   213

        if (symbol->subrange != NULL) {

   214

          current_type_name->accept(*this);

   215

          s4o.print(" __CHECK_");

   216

          current_type_name->accept(*this);

   217

          s4o.print("(");

   218

          current_type_name->accept(*this);

   219

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

   220

          s4o.indent_right();

   221

   222

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

   223

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

   224

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

   225

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

   226

          }

   227

   228

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

   229

   230

          s4o.indent_left();

   231

          s4o.print("}\n");

   232

        }

   233

        else {

   234

          s4o.print("#define __CHECK_");

   235

          current_type_name->accept(*this);

   236

          s4o.print(" __CHECK_");

   237

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

   238

          s4o.print("\n");

   239

        }

   240

        break;

   241

      default:

   242

        break;

   243

    }

   244

  }

   245

  else {

   246

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

   247

  }

   248

  return NULL;

   249

}

   250

   251

/*  signed_integer DOTDOT signed_integer */

   252

void *visit(subrange_c *symbol) {

   253

  int dimension;

   254

  switch (current_typedefinition) {

   255

    case array_td:

   256

      if (current_basetypedeclaration == arraysubrange_bd) {

   257

        s4o_incl.print("[");

   259

        print_integer_incl(dimension);

   260

        s4o_incl.print("]");

   261

      }

   262

      else

   263

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

   264

      break;

   265

    case subrange_td:

   266

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

   267

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

   268

      s4o.print(")\n");

   269

      s4o.indent_right();

   270

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

   271

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

   272

      s4o.print(";\n");

   273

      s4o.indent_left();

   274

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

   275

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

   276

      s4o.print(")\n");

   277

      s4o.indent_right();

   278

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

   279

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

   280

      s4o.print(";\n");

   281

      s4o.indent_left();

   282

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

   283

      s4o.indent_right();

   284

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

   285

      s4o.indent_left();

   286

    default:

   287

      break;

   288

  }

   289

  return NULL;

   290

}

   291

   292

/*  enumerated_type_name ':' enumerated_spec_init */

   293

void *visit(enumerated_type_declaration_c *symbol) {

   294

  TRACE("enumerated_type_declaration_c");

   295

   296

  current_typedefinition = enumerated_td;

   297

  current_type_name = symbol->enumerated_type_name;

   298

   299

  s4o_incl.print("__DECLARE_ENUMERATED_TYPE(");

   300

  current_type_name->accept(*basedecl);

   301

  s4o_incl.print(",\n");

   302

  s4o_incl.indent_right();

   303

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

   304

  s4o_incl.indent_left();

   305

  s4o_incl.print(")\n");

   306

   307

  current_type_name = NULL;

   308

  current_typedefinition = none_td;

   309

   310

  return NULL;

   311

}

   312

   313

/* enumerated_specification ASSIGN enumerated_value */

   314

void *visit(enumerated_spec_init_c *symbol) {

   315

  TRACE("enumerated_spec_init_c");

   316

  if (current_typedefinition == enumerated_td)

   317

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

   318

  else

   319

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

   320

  return NULL;

   321

}

   322

   323

/* helper symbol for enumerated_specification->enumerated_spec_init */

   324

/* enumerated_value_list ',' enumerated_value */

   325

void *visit(enumerated_value_list_c *symbol) {

   326

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

   327

  return NULL;

   328

}

   329

   330

/* enumerated_type_name '#' identifier */

   331

void *visit(enumerated_value_c *symbol) {

   332

  symbol_c *value_type;

   333

  if (current_typedefinition == enumerated_td)

   334

    current_type_name->accept(*basedecl);

   335

  else {

   336

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

   337

    if (value_type == NULL) ERROR;

   338

   339

    value_type->accept(*basedecl);

   340

  }

   341

  s4o_incl.print("__");

   342

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

   343

  return NULL;

   344

}

   345

   346

/*  identifier ':' array_spec_init */

   347

void *visit(array_type_declaration_c *symbol) {

   348

  TRACE("array_type_declaration_c");

   349

   350

  current_typedefinition = array_td;

   351

  current_type_name = symbol->identifier;

   352

   353

  array_is_derived = false;

   354

  current_basetypedeclaration = arrayderiveddeclaration_bd;

   355

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

   356

  current_basetypedeclaration = none_bd;

   357

   358

  if (array_is_derived)

   359

	s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   360

  else

   361

	s4o_incl.print("__DECLARE_ARRAY_TYPE(");

   362

  current_type_name->accept(*basedecl);

   363

  s4o_incl.print(",");

   364

  current_basetypedeclaration = arraybasetypeincl_bd;

   365

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

   366

  current_basetypedeclaration = none_bd;

   367

  if (!array_is_derived) {

   368

	s4o_incl.print(",");

   369

	current_basetypedeclaration = arraysubrange_bd;

   370

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

   371

	current_basetypedeclaration = none_bd;

   372

  }

   373

  s4o_incl.print(")\n");

   374

   375

  current_type_name = NULL;

   376

  current_typedefinition = none_td;

   377

   378

  return NULL;

   379

}

   380

   381

/* array_specification [ASSIGN array_initialization] */

   382

/* array_initialization may be NULL ! */

   383

void *visit(array_spec_init_c *symbol) {

   384

  TRACE("array_spec_init_c");

   385

   386

  if (current_typedefinition == array_td) {

   387

    switch (current_basetypedeclaration) {

   388

	  case arrayderiveddeclaration_bd:

   389

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

   390

	    break;

   391

	  default:

   392

	    if (array_is_derived)

   393

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

   394

	    else

   395

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

   396

	    break;

   397

    }

   398

  }

   399

  else {

   400

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

   401

  }

   402

  return NULL;

   403

}

   404

   405

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

   406

void *visit(array_specification_c *symbol) {

   407

  switch (current_basetypedeclaration) {

   408

    case arraybasetype_bd:

   409

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

   410

      break;

   411

    case arraybasetypeincl_bd:

   412

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

   413

      break;

   414

    case arraysubrange_bd:

   415

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

   416

      break;

   417

    default:

   418

      break;

   419

  }

   420

  return NULL;

   421

}

   422

   423

/* helper symbol for array_specification */

   424

/* array_subrange_list ',' subrange */

   425

void *visit(array_subrange_list_c *symbol) {

   426

  print_list(symbol);

   427

  return NULL;

   428

}

   429

   430

/*  TYPE type_declaration_list END_TYPE */

   431

void *visit(data_type_declaration_c *symbol) {

   432

  TRACE("data_type_declaration_c");

   433

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

   434

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

   435

  return NULL;

   436

}

   437

   438

/* helper symbol for data_type_declaration */

   439

void *visit(type_declaration_list_c *symbol) {

   440

  TRACE("type_declaration_list_c");

   441

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

   442

}

   443

   444

/*  simple_type_name ':' simple_spec_init */

   445

void *visit(simple_type_declaration_c *symbol) {

   446

  TRACE("simple_type_declaration_c");

   447

   448

  s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   449

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

   450

  s4o_incl.print(",");

   451

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

   452

  s4o_incl.print(")\n");

   453

   454

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

   455

	s4o.print("#define __CHECK_");

   456

	current_type_name->accept(*this);

   457

	s4o.print(" __CHECK_");

   458

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

   459

	s4o.print("\n");

   460

  }

   461

   462

  return NULL;

   463

}

   464

   465

/* simple_specification [ASSIGN constant] */

   466

//SYM_REF2(simple_spec_init_c, simple_specification, constant)

   467

// <constant> may be NULL

   468

void *visit(simple_spec_init_c *symbol) {

   469

  TRACE("simple_spec_init_c");

   470

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

   471

  return NULL;

   472

}

   473

   474

#if 0

   475

/*  subrange_type_name ':' subrange_spec_init */

   476

SYM_REF2(subrange_type_declaration_c, subrange_type_name, subrange_spec_init)

   477

   478

/* subrange_specification ASSIGN signed_integer */

   479

SYM_REF2(subrange_spec_init_c, subrange_specification, signed_integer)

   480

   481

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

   482

SYM_REF2(subrange_specification_c, integer_type_name, subrange)

   483

   484

/*  signed_integer DOTDOT signed_integer */

   485

SYM_REF2(subrange_c, lower_limit, upper_limit)

   486

   487

/*  enumerated_type_name ':' enumerated_spec_init */

   488

SYM_REF2(enumerated_type_declaration_c, enumerated_type_name, enumerated_spec_init)

   489

   490

/* enumerated_specification ASSIGN enumerated_value */

   491

SYM_REF2(enumerated_spec_init_c, enumerated_specification, enumerated_value)

   492

   493

/* helper symbol for enumerated_specification->enumerated_spec_init */

   494

/* enumerated_value_list ',' enumerated_value */

   495

SYM_LIST(enumerated_value_list_c)

   496

   497

/* enumerated_type_name '#' identifier */