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

      arraytranslateindex_bd

    75

    } basetypedeclaration_t;

    76

    77

    basetypedeclaration_t current_basetypedeclaration;

    78

    79

    void print_integer(unsigned int integer) {

    80

      char str[10];

    81

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

    82

      s4o.print(str);

    83

    }

    84

    85

    void print_integer_incl(unsigned int integer) {

    86

      char str[10];

    87

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

    88

      s4o_incl.print(str);

    89

    }

    90

    91

    void *print_list_incl(list_c *list,

    92

         std::string pre_elem_str = "",

    93

         std::string inter_elem_str = "",

    94

         std::string post_elem_str = "",

    95

         visitor_c *visitor = NULL) {

    96

      if (visitor == NULL) visitor = this;

    97

    98

      if (list->n > 0) {

    99

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

   100

        s4o_incl.print(pre_elem_str);

   101

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

   102

      }

   103

   104

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

   105

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

   106

        s4o_incl.print(inter_elem_str);

   107

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

   108

      }

   109

   110

      if (list->n > 0)

   111

        s4o_incl.print(post_elem_str);

   112

   113

      return NULL;

   114

    }

   115

   116

   117

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

   118

/* B 0 - Programming Model */

   119

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

   120

  /* leave for derived classes... */

   121

   122

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

   123

/* B.1 - Common elements */

   124

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

   125

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

   126

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

   127

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

   128

  /* done in base class(es) */

   129

   130

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

   131

/* B 1.2 - Constants */

   132

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

   133

  /* originally empty... */

   134

   135

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

   136

/* B 1.2.1 - Numeric Literals */

   137

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

   138

  /* done in base class(es) */

   139

   140

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

   141

/* B.1.2.2   Character Strings */

   142

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

   143

  /* done in base class(es) */

   144

   145

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

   146

/* B 1.2.3 - Time Literals */

   147

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

   148

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

   149

/* B 1.2.3.1 - Duration */

   150

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

   151

  /* done in base class(es) */

   152

   153

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

   154

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

   155

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

   156

  /* done in base class(es) */

   157

   158

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

   159

/* B.1.3 - Data types */

   160

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

   161

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

   162

/* B 1.3.1 - Elementary Data Types */

   163

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

   164

  /* done in base class(es) */

   165

   166

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

   167

/* B.1.3.2 - Generic data types */

   168

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

   169

  /* originally empty... */

   170

   171

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

   172

/* B 1.3.3 - Derived data types */

   173

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

   174

/*  subrange_type_name ':' subrange_spec_init */

   175

void *visit(subrange_type_declaration_c *symbol) {

   176

  TRACE("subrange_type_declaration_c");  

   177

   178

  current_typedefinition = subrange_td;

   179

  current_type_name = symbol->subrange_type_name;

   180

   181

  s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   182

  current_type_name->accept(*basedecl);

   183

  s4o_incl.print(",");

   184

  current_basetypedeclaration = subrangebasetype_bd;

   185

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

   186

  current_basetypedeclaration = none_bd;

   187

  s4o_incl.print(")\n");

   188

   189

  current_basetypedeclaration = subrangetest_bd;

   190

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

   191

  current_basetypedeclaration = none_bd;

   192

   193

  current_type_name = NULL;

   194

  current_typedefinition = none_td;

   195

   196

  return NULL;

   197

}

   198

   199

/* subrange_specification ASSIGN signed_integer */

   200

void *visit(subrange_spec_init_c *symbol) {

   201

  TRACE("subrange_spec_init_c");

   202

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

   203

  return NULL;

   204

}

   205

   206

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

   207

void *visit(subrange_specification_c *symbol) {

   208

  if (current_typedefinition == subrange_td) {

   209

    switch (current_basetypedeclaration) {

   210

      case subrangebasetype_bd:

   211

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

   212

        break;

   213

      case subrangetest_bd:

   214

        if (symbol->subrange != NULL) {

   215

          current_type_name->accept(*this);

   216

          s4o.print(" __CHECK_");

   217

          current_type_name->accept(*this);

   218

          s4o.print("(");

   219

          current_type_name->accept(*this);

   220

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

   221

          s4o.indent_right();

   222

   223

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

   224

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

   225

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

   226

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

   227

          }

   228

   229

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

   230

   231

          s4o.indent_left();

   232

          s4o.print("}\n");

   233

        }

   234

        else {

   235

          s4o.print("#define __CHECK_");

   236

          current_type_name->accept(*this);

   237

          s4o.print(" __CHECK_");

   238

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

   239

          s4o.print("\n");

   240

        }

   241

        break;

   242

      default:

   243

        break;

   244

    }

   245

  }

   246

  else {

   247

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

   248

  }

   249

  return NULL;

   250

}

   251

   252

/*  signed_integer DOTDOT signed_integer */

   253

void *visit(subrange_c *symbol) {

   254

  int dimension;

   255

  switch (current_typedefinition) {

   256

    case array_td:

   257

      if (current_basetypedeclaration == arraysubrange_bd) {

   258

        s4o_incl.print("[");

   259

        dimension = extract_integer(symbol->upper_limit) - extract_integer(symbol->lower_limit) + 1;

   260

        print_integer_incl(dimension);

   261

        s4o_incl.print("]");

   262

      }

   263

      else

   264

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

   265

      break;

   266

    case subrange_td:

   267

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

   268

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

   269

      s4o.print(")\n");

   270

      s4o.indent_right();

   271

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

   272

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

   273

      s4o.print(";\n");

   274

      s4o.indent_left();

   275

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

   276

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

   277

      s4o.print(")\n");

   278

      s4o.indent_right();

   279

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

   280

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

   281

      s4o.print(";\n");

   282

      s4o.indent_left();

   283

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

   284

      s4o.indent_right();

   285

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

   286

      s4o.indent_left();

   287

    default:

   288

      break;

   289

  }

   290

  return NULL;

   291

}

   292

   293

/*  enumerated_type_name ':' enumerated_spec_init */

   294

void *visit(enumerated_type_declaration_c *symbol) {

   295

  TRACE("enumerated_type_declaration_c");

   296

   297

  current_typedefinition = enumerated_td;

   298

  current_type_name = symbol->enumerated_type_name;

   299

   300

  s4o_incl.print("__DECLARE_ENUMERATED_TYPE(");

   301

  current_type_name->accept(*basedecl);

   302

  s4o_incl.print(",\n");

   303

  s4o_incl.indent_right();

   304

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

   305

  s4o_incl.indent_left();

   306

  s4o_incl.print(")\n");

   307

   308

  current_type_name = NULL;

   309

  current_typedefinition = none_td;

   310

   311

  return NULL;

   312

}

   313

   314

/* enumerated_specification ASSIGN enumerated_value */

   315

void *visit(enumerated_spec_init_c *symbol) {

   316

  TRACE("enumerated_spec_init_c");

   317

  if (current_typedefinition == enumerated_td)

   318

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

   319

  else

   320

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

   321

  return NULL;

   322

}

   323

   324

/* helper symbol for enumerated_specification->enumerated_spec_init */

   325

/* enumerated_value_list ',' enumerated_value */

   326

void *visit(enumerated_value_list_c *symbol) {

   327

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

   328

  return NULL;

   329

}

   330

   331

/* enumerated_type_name '#' identifier */

   332

void *visit(enumerated_value_c *symbol) {

   333

  symbol_c *value_type;

   334

  if (current_typedefinition == enumerated_td)

   335

    current_type_name->accept(*basedecl);

   336

  else {

   337

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

   338

    if (value_type == NULL) ERROR;

   339

   340

    value_type->accept(*basedecl);

   341

  }

   342

  s4o_incl.print("__");

   343

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

   344

  return NULL;

   345

}

   346

   347

/*  identifier ':' array_spec_init */

   348

void *visit(array_type_declaration_c *symbol) {

   349

  TRACE("array_type_declaration_c");

   350

   351

  current_typedefinition = array_td;

   352

  current_type_name = symbol->identifier;

   353

   354

  array_is_derived = false;

   355

  current_basetypedeclaration = arrayderiveddeclaration_bd;

   356

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

   357

  current_basetypedeclaration = none_bd;

   358

   359

  if (array_is_derived)

   360

	s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   361

  else

   362

	s4o_incl.print("__DECLARE_ARRAY_TYPE(");

   363

  current_type_name->accept(*basedecl);

   364

  s4o_incl.print(",");

   365

  current_basetypedeclaration = arraybasetypeincl_bd;

   366

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

   367

  current_basetypedeclaration = none_bd;

   368

  if (!array_is_derived) {

   369

	s4o_incl.print(",");

   370

	current_basetypedeclaration = arraysubrange_bd;

   371

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

   372

	current_basetypedeclaration = none_bd;

   373

  }

   374

  s4o_incl.print(")\n");

   375

   376

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

   377

	s4o.print("#define __CHECK_");

   378

	current_type_name->accept(*this);

   379

	s4o.print(" __CHECK_");

   380

	current_basetypedeclaration = arraybasetype_bd;

   381

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

   382

	current_basetypedeclaration = none_bd;

   383

	s4o.print("\n");

   384

  }

   385

   386

  current_basetypedeclaration = arraytranslateindex_bd;

   387

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

   388

  current_basetypedeclaration = none_bd;

   389

  s4o.print("\n");

   390

   391

  current_type_name = NULL;

   392

  current_typedefinition = none_td;

   393

   394

  return NULL;

   395

}

   396

   397

/* array_specification [ASSIGN array_initialization] */

   398

/* array_initialization may be NULL ! */

   399

void *visit(array_spec_init_c *symbol) {

   400

  TRACE("array_spec_init_c");

   401

   402

  if (current_typedefinition == array_td) {

   403

    switch (current_basetypedeclaration) {

   404

	  case arrayderiveddeclaration_bd:

   405

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

   406

	    break;

   407

	  case arraytranslateindex_bd:

   408

	    if (!array_is_derived)

   409

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

   410

	    s4o.print("#define __");

   411

	    current_type_name->accept(*this);

   412

	    s4o.print("_TRANSIDX(row, index) __");

   413

	    if (array_is_derived)

   414

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

   415

	    else

   416

		   current_type_name->accept(*this);

   417

	    s4o.print("_TRANSIDX##row(index)");

   418

	    break;

   419

	  default:

   420

	    if (array_is_derived)

   421

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

   422

	    else

   423

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

   424

	    break;

   425

    }

   426

  }

   427

  else {

   428

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

   429

  }

   430

  return NULL;

   431

}

   432

   433

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

   434

void *visit(array_specification_c *symbol) {

   435

  switch (current_basetypedeclaration) {

   436

    case arraybasetype_bd:

   437

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

   438

      break;

   439

    case arraybasetypeincl_bd:

   440

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

   441

      break;

   442

    case arraysubrange_bd:

   443

    case arraytranslateindex_bd:

   444

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

   445

      break;

   446

    default:

   447

      break;

   448

  }

   449

  return NULL;

   450

}

   451

   452

/* helper symbol for array_specification */

   453

/* array_subrange_list ',' subrange */

   454

void *visit(array_subrange_list_c *symbol) {

   455

  if (current_basetypedeclaration == arraytranslateindex_bd) {

   456

    for (int i = 0; i < symbol->n; i++) {

   457

      s4o.print("#define __");

   458

      current_type_name->accept(*this);

   459

      s4o.print("_TRANSIDX");

   460

      print_integer(i);

   461

      s4o.print("(index) (index) - ");

   462

      symbol->elements[i]->accept(*this);

   463

      s4o.print("\n");

   464

    }

   465

  }

   466

  else

   467

    print_list(symbol);

   468

  return NULL;

   469

}

   470

   471

/*  TYPE type_declaration_list END_TYPE */

   472

void *visit(data_type_declaration_c *symbol) {

   473

  TRACE("data_type_declaration_c");

   474

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

   475

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

   476

  return NULL;

   477

}

   478

   479

/* helper symbol for data_type_declaration */

   480

void *visit(type_declaration_list_c *symbol) {

   481

  TRACE("type_declaration_list_c");

   482

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

   483

}

   484

   485

/*  simple_type_name ':' simple_spec_init */

   486

void *visit(simple_type_declaration_c *symbol) {

   487

  TRACE("simple_type_declaration_c");

   488

   489

  s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   490

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

   491

  s4o_incl.print(",");

   492

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

   493

  s4o_incl.print(")\n");

   494

  return NULL;

   495

}