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

    36

    generate_c_base_c *basedecl;

    37

    38

  public:

    39

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

    40

      current_typedefinition = none_td;

    41

      current_basetypedeclaration = none_bd;

    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

      basedecl = new generate_c_base_c(&s4o_incl);

    48

    }

    49

    ~generate_c_typedecl_c(void) {

    50

      delete basedecl;

    51

    }

    52

    53

    typedef enum {

    54

      none_td,

    55

      enumerated_td,

    56

      subrange_td,

    57

      array_td,

    58

      struct_td,

    59

    } typedefinition_t;

    60

    61

    typedefinition_t current_typedefinition;

    62

    63

    typedef enum {

    64

      none_bd,

    65

      subrangebasetype_bd,

    66

      subrangetest_bd,

    67

      arrayderiveddeclaration_bd,

    68

      arraybasetype_bd,

    69

      arraybasetypeincl_bd,

    70

      arraysubrange_bd,

    71

      arraytranslateindex_bd

    72

    } basetypedeclaration_t;

    73

    74

    basetypedeclaration_t current_basetypedeclaration;

    75

    76

    int extract_integer(symbol_c *integer) {

    77

      return atoi(((integer_c *)integer)->value);

    78

    }

    79

    80

    void print_integer(unsigned int integer) {

    81

      char str[10];

    82

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

    83

      s4o.print(str);

    84

    }

    85

    86

    void print_integer_incl(unsigned int integer) {

    87

      char str[10];

    88

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

    89

      s4o_incl.print(str);

    90

    }

    91

    92

    void *print_list_incl(list_c *list,

    93

         std::string pre_elem_str = "",

    94

         std::string inter_elem_str = "",

    95

         std::string post_elem_str = "",

    96

         visitor_c *visitor = NULL) {

    97

      if (visitor == NULL) visitor = this;

    98

    99

      if (list->n > 0) {

   100

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

   101

        s4o_incl.print(pre_elem_str);

   102

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

   103

      }

   104

   105

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

   106

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

   107

        s4o_incl.print(inter_elem_str);

   108

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

   109

      }

   110

   111

      if (list->n > 0)

   112

        s4o_incl.print(post_elem_str);

   113

   114

      return NULL;

   115

    }

   116

   117

   118

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

   119

/* B 0 - Programming Model */

   120

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

   121

  /* leave for derived classes... */

   122

   123

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

   124

/* B.1 - Common elements */

   125

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

   126

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

   127

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

   128

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

   129

  /* done in base class(es) */

   130

   131

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

   132

/* B 1.2 - Constants */

   133

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

   134

  /* originally empty... */

   135

   136

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

   137

/* B 1.2.1 - Numeric Literals */

   138

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

   139

  /* done in base class(es) */

   140

   141

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

   142

/* B.1.2.2   Character Strings */

   143

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

   144

  /* done in base class(es) */

   145

   146

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

   147

/* B 1.2.3 - Time Literals */

   148

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

   149

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

   150

/* B 1.2.3.1 - Duration */

   151

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

   152

  /* done in base class(es) */

   153

   154

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

   155

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

   156

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

   157

  /* done in base class(es) */

   158

   159

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

   160

/* B.1.3 - Data types */

   161

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

   162

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

   163

/* B 1.3.1 - Elementary Data Types */

   164

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

   165

  /* done in base class(es) */

   166

   167

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

   168

/* B.1.3.2 - Generic data types */

   169

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

   170

  /* originally empty... */

   171

   172

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

   173

/* B 1.3.3 - Derived data types */

   174

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

   175

/*  subrange_type_name ':' subrange_spec_init */

   176

void *visit(subrange_type_declaration_c *symbol) {

   177

  TRACE("subrange_type_declaration_c");  

   178

   179

  current_typedefinition = subrange_td;

   180

   181

  s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   182

  current_basetypedeclaration = subrangebasetype_bd;

   183

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

   184

  current_basetypedeclaration = none_bd;

   185

  s4o_incl.print(",");

   186

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

   187

  s4o_incl.print(")\n");

   188

   189

  current_type_name = symbol->subrange_type_name;

   190

   191

  current_basetypedeclaration = subrangetest_bd;

   192

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

   193

  current_basetypedeclaration = none_bd;

   194

   195

  current_typedefinition = none_td;

   196

   197

  return NULL;

   198

}

   199

   200

/* subrange_specification ASSIGN signed_integer */

   201

void *visit(subrange_spec_init_c *symbol) {

   202

  TRACE("subrange_spec_init_c");

   203

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

   204

  return NULL;

   205

}

   206

   207

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

   208

void *visit(subrange_specification_c *symbol) {

   209

  if (current_typedefinition == subrange_td) {

   210

    switch (current_basetypedeclaration) {

   211

      case subrangebasetype_bd:

   212

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

   213

        break;

   214

      case subrangetest_bd:

   215

        if (symbol->subrange != NULL) {

   216

          current_type_name->accept(*this);

   217

          s4o.print(" __CHECK_");

   218

          current_type_name->accept(*this);

   219

          s4o.print("(");

   220

          current_type_name->accept(*this);

   221

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

   222

          s4o.indent_right();

   223

   224

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

   225

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

   226

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

   227

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

   228

          }

   229

   230

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

   231

   232

          s4o.indent_left();

   233

          s4o.print("}\n");

   234

        }

   235

        else {

   236

          s4o.print("#define __CHECK_");

   237

          current_type_name->accept(*this);

   238

          s4o.print(" __CHECK_");

   239

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

   240

          s4o.print("\n");

   241

        }

   242

        break;

   243

      default:

   244

        break;

   245

    }

   246

  }

   247

  else {

   248

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

   249

  }

   250

  return NULL;

   251

}

   252

   253

/*  signed_integer DOTDOT signed_integer */

   254

void *visit(subrange_c *symbol) {

   255

  int dimension;

   256

  switch (current_typedefinition) {

   257

    case array_td:

   258

      if (current_basetypedeclaration == arraysubrange_bd) {

   259

        s4o_incl.print("[");

   260

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

   261

        print_integer_incl(dimension);

   262

        s4o_incl.print("]");

   263

      }

   264

      else

   265

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

   266

      break;

   267

    case subrange_td:

   268

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

   269

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

   270

      s4o.print(")\n");

   271

      s4o.indent_right();

   272

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

   273

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

   274

      s4o.print(";\n");

   275

      s4o.indent_left();

   276

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

   277

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

   278

      s4o.print(")\n");

   279

      s4o.indent_right();

   280

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

   281

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

   282

      s4o.print(";\n");

   283

      s4o.indent_left();

   284

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

   285

      s4o.indent_right();

   286

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

   287

      s4o.indent_left();

   288

    default:

   289

      break;

   290

  }

   291

  return NULL;

   292

}

   293

   294

/*  enumerated_type_name ':' enumerated_spec_init */

   295

void *visit(enumerated_type_declaration_c *symbol) {

   296

  TRACE("enumerated_type_declaration_c");

   297

   298

  current_typedefinition = enumerated_td;

   299

   300

  s4o_incl.print("typedef enum {\n");

   301

  s4o_incl.indent_right();

   302

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

   303

  s4o_incl.indent_left();

   304

  s4o_incl.print("} ");

   305

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

   306

  s4o_incl.print(";\n");

   307

   308

  current_typedefinition = none_td;

   309

   310

  return NULL;

   311

}

   312

   313

void *visit(enumerated_spec_init_c *symbol) {

   314

  TRACE("enumerated_spec_init_c");

   315

  if (current_typedefinition == enumerated_td)

   316

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

   317

  else

   318

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

   319

  return NULL;

   320

}

   321

   322

/* helper symbol for enumerated_specification->enumerated_spec_init */

   323

/* enumerated_value_list ',' enumerated_value */

   324

void *visit(enumerated_value_list_c *symbol) {

   325

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

   326

  return NULL;

   327

}

   328

   329

/* enumerated_type_name '#' identifier */

   330

void *visit(enumerated_value_c *symbol) {

   331

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

   332

  return NULL;

   333

}

   334

   335

/*  identifier ':' array_spec_init */

   336

void *visit(array_type_declaration_c *symbol) {

   337

  TRACE("array_type_declaration_c");

   338

   339

  current_typedefinition = array_td;

   340

   341

  array_is_derived = false;

   342

  current_basetypedeclaration = arrayderiveddeclaration_bd;

   343

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

   344

  current_basetypedeclaration = none_bd;

   345

   346

  if (array_is_derived)

   347

	s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   348

  else

   350

  current_basetypedeclaration = arraybasetypeincl_bd;

   351

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

   352

  current_basetypedeclaration = none_bd;

   353

  s4o_incl.print(",");

   354

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

   355

  if (!array_is_derived) {

   360

  }

   361

  s4o_incl.print(")\n");

   363

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

   371

  }

   373

  current_type_name = symbol->identifier;

   374

  current_basetypedeclaration = arraytranslateindex_bd;

   375

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

   376

  current_basetypedeclaration = none_bd;

   377

  s4o.print("\n");

   379

  current_typedefinition = none_td;

   380

   381

  return NULL;

   382

}

   383

   384

/* array_specification [ASSIGN array_initialization] */

   385

/* array_initialization may be NULL ! */

   386

void *visit(array_spec_init_c *symbol) {

   387

  TRACE("array_spec_init_c");

   388

   416

  }

   417

  return NULL;

   418

}

   419

   420

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

   421

void *visit(array_specification_c *symbol) {

   422

  switch (current_basetypedeclaration) {

   423

    case arraybasetype_bd:

   424

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

   425

      break;

   426

    case arraybasetypeincl_bd:

   427

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

   428

      break;

   429

    case arraysubrange_bd:

   430

    case arraytranslateindex_bd:

   431

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

   432

      break;

   433

    default:

   434

      break;

   435

  }

   436

  return NULL;

   437

}

   438

   439

/* helper symbol for array_specification */

   440

/* array_subrange_list ',' subrange */

   441

void *visit(array_subrange_list_c *symbol) {

   442

  if (current_basetypedeclaration == arraytranslateindex_bd) {

   443

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

   444

      s4o.print("#define __");

   445

      current_type_name->accept(*this);

   446

      s4o.print("_TRANSIDX");

   447

      print_integer(i);

   448

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

   449

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

   450

      s4o.print("\n");

   451

    }

   452

  }

   453

  else

   454

    print_list(symbol);

   455

  return NULL;

   456

}

   457

   458

/*  TYPE type_declaration_list END_TYPE */

   459

void *visit(data_type_declaration_c *symbol) {

   460

  TRACE("data_type_declaration_c");

   461

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

   462

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

   463

  return NULL;

   464

}

   465

   466

/* helper symbol for data_type_declaration */

   467

void *visit(type_declaration_list_c *symbol) {

   468

  TRACE("type_declaration_list_c");

   469

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

   470

}

   471

   472

/*  simple_type_name ':' simple_spec_init */

   473

void *visit(simple_type_declaration_c *symbol) {

   474

  TRACE("simple_type_declaration_c");

   475

   476

  s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   477

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

   478

  s4o_incl.print(",");

   479

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

   480

  s4o_incl.print(")\n");

   481

  return NULL;

   482

}

   483

   484

/* simple_specification [ASSIGN constant] */

   485

//SYM_REF2(simple_spec_init_c, simple_specification, constant)

   486

// <constant> may be NULL

   487

void *visit(simple_spec_init_c *symbol) {

   488

  TRACE("simple_spec_init_c");

   489

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

   490

  return NULL;

   491

}

   492

   493

#if 0

   494

/*  subrange_type_name ':' subrange_spec_init */

   495

SYM_REF2(subrange_type_declaration_c, subrange_type_name, subrange_spec_init)

   496

   497

/* subrange_specification ASSIGN signed_integer */