1

/*

    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

    search_base_type_c search_base_type;

    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

      basedecl = new generate_c_base_c(&s4o_incl);

    42

    }

    43

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

    44

      current_typedefinition = none_td;

    45

      current_basetypedeclaration = none_bd;

    46

      basedecl = new generate_c_base_c(&s4o_incl);

    47

    }

    48

    ~generate_c_typedecl_c(void) {

    49

      delete basedecl;

    50

    }

    51

    52

    typedef enum {

    53

      none_td,

    54

      subrange_td,

    55

      array_td

    56

    } typedefinition_t;

    57

    58

    typedefinition_t current_typedefinition;

    59

    60

    typedef enum {

    61

      none_bd,

    62

      subrangebasetype_bd,

    63

      subrangetest_bd,

    64

      arraybasetype_bd,

    65

      arraybasetypeincl_bd,

    66

      arraysubrange_bd,

    67

      arraytranslateindex_bd

    68

    } basetypedeclaration_t;

    69

    70

    basetypedeclaration_t current_basetypedeclaration;

    71

    72

    int extract_integer(symbol_c *integer) {

    73

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

    74

    }

    75

    76

    void print_integer(unsigned int integer) {

    77

      char str[10];

    78

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

    79

      s4o.print(str);

    80

    }

    81

    82

    void print_integer_incl(unsigned int integer) {

    83

      char str[10];

    84

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

    85

      s4o_incl.print(str);

    86

    }

    87

    88

    void *print_list_incl(list_c *list,

    89

         std::string pre_elem_str = "",

    90

         std::string inter_elem_str = "",

    91

         std::string post_elem_str = "",

    92

         visitor_c *visitor = NULL) {

    93

      if (visitor == NULL) visitor = this;

    94

    95

      if (list->n > 0) {

    96

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

    97

        s4o_incl.print(pre_elem_str);

    98

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

    99

      }

   100

   101

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

   102

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

   103

        s4o_incl.print(inter_elem_str);

   104

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

   105

      }

   106

   107

      if (list->n > 0)

   108

        s4o_incl.print(post_elem_str);

   109

   110

      return NULL;

   111

    }

   112

   113

   114

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

   115

/* B 0 - Programming Model */

   116

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

   117

  /* leave for derived classes... */

   118

   119

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

   120

/* B.1 - Common elements */

   121

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

   122

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

   123

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

   124

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

   125

  /* done in base class(es) */

   126

   127

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

   128

/* B 1.2 - Constants */

   129

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

   130

  /* originally empty... */

   131

   132

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

   133

/* B 1.2.1 - Numeric Literals */

   134

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

   135

  /* done in base class(es) */

   136

   137

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

   138

/* B.1.2.2   Character Strings */

   139

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

   140

  /* done in base class(es) */

   141

   142

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

   143

/* B 1.2.3 - Time Literals */

   144

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

   145

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

   146

/* B 1.2.3.1 - Duration */

   147

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

   148

  /* done in base class(es) */

   149

   150

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

   151

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

   152

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

   153

  /* done in base class(es) */

   154

   155

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

   156

/* B.1.3 - Data types */

   157

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

   158

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

   159

/* B 1.3.1 - Elementary Data Types */

   160

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

   161

  /* done in base class(es) */

   162

   163

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

   164

/* B.1.3.2 - Generic data types */

   165

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

   166

  /* originally empty... */

   167

   168

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

   169

/* B 1.3.3 - Derived data types */

   170

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

   171

/*  subrange_type_name ':' subrange_spec_init */

   172

void *visit(subrange_type_declaration_c *symbol) {

   173

  TRACE("subrange_type_declaration_c");  

   174

   175

  s4o_incl.print("__DECLARE_DERIVED_TYPE(");

   176

  current_basetypedeclaration = subrangebasetype_bd;

   177

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

   178

  current_basetypedeclaration = none_bd;

   179

  s4o_incl.print(", ");

   180

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

   181

  s4o_incl.print(")\n");

   182

   183

  current_type_name = symbol->subrange_type_name;

   184

   185

  current_basetypedeclaration = subrangetest_bd;

   186

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

   187

  current_basetypedeclaration = none_bd;

   188

   189

  return NULL;

   190

}

   191

   192

/* subrange_specification ASSIGN signed_integer */

   193

void *visit(subrange_spec_init_c *symbol) {

   194

  TRACE("subrange_spec_init_c");

   195

  current_typedefinition = subrange_td;

   196

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

   197

  current_typedefinition = none_td;

   198

  return NULL;

   199

}

   200

   201

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

   202

void *visit(subrange_specification_c *symbol) {

   203

  switch (current_basetypedeclaration) {

   204

    case subrangebasetype_bd:

   205

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

   206

      break;

   207

    case subrangetest_bd:

   208

      if (symbol->subrange != NULL) {

   209

        current_type_name->accept(*this);

   210

        s4o.print(" __CHECK_");

   211

        current_type_name->accept(*this);

   212

        s4o.print("(");

   213

        current_type_name->accept(*this);

   214

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

   215

        s4o.indent_right();

   216

   217

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

   218

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

   219

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

   220

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

   221

        }

   222

   223

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

   224

   225

        s4o.indent_left();

   226

        s4o.print("}\n");

   227

      }

   228

      else {

   229

        s4o.print("#define __CHECK_");

   230

        current_type_name->accept(*this);

   231

        s4o.print(" __CHECK_");

   232

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

   233

        s4o.print("\n");

   234

      } 

   235

      break;

   236

    default:

   237

      break;

   238

  }

   239

  return NULL;

   240

}

   241

   242

/*  signed_integer DOTDOT signed_integer */

   243

void *visit(subrange_c *symbol) {

   244

  int dimension;

   245

  switch (current_typedefinition) {

   246

    case array_td:

   247

      if (current_basetypedeclaration == arraysubrange_bd) {

   248

        s4o_incl.print("[");

   249

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

   250

        print_integer_incl(dimension);

   251

        s4o_incl.print("]");

   252

      }

   253

      else

   254

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

   255

      break;

   256

    case subrange_td:

   257

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

   258

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

   259

      s4o.print(")\n");

   260

      s4o.indent_right();

   261

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

   262

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

   263

      s4o.print(";\n");

   264

      s4o.indent_left();

   265

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

   266

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

   267

      s4o.print(")\n");

   268

      s4o.indent_right();

   269

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

   270

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

   271

      s4o.print(";\n");

   272

      s4o.indent_left();

   273

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

   274

      s4o.indent_right();

   275

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

   276

      s4o.indent_left();

   277

    default:

   278

      break;

   279

  }

   280

  return NULL;

   281

}

   282

   283

/*  enumerated_type_name ':' enumerated_spec_init */

   284

void *visit(enumerated_type_declaration_c *symbol) {

   285

  TRACE("enumerated_type_declaration_c");

   286

   287

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

   288

  s4o_incl.indent_right();

   289

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

   290

  s4o_incl.indent_left();

   291

  s4o_incl.print("} ");

   292

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

   293

  s4o_incl.print(";\n");

   294

  return NULL;

   295

}

   296

   297

void *visit(enumerated_spec_init_c *symbol) {

   298

  TRACE("enumerated_spec_init_c");

   299

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

   300

  return NULL;

   301

}

   302

   303

/* helper symbol for enumerated_specification->enumerated_spec_init */

   304

/* enumerated_value_list ',' enumerated_value */

   305

void *visit(enumerated_value_list_c *symbol) {

   306

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

   307

  return NULL;

   308

}

   309

   310

/* enumerated_type_name '#' identifier */

   311

void *visit(enumerated_value_c *symbol) {

   312

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

   313

  return NULL;

   314

}

   315

   316

/*  identifier ':' array_spec_init */

   317

void *visit(array_type_declaration_c *symbol) {

   318

  TRACE("array_type_declaration_c");

   319

   320

  s4o_incl.print("__DECLARE_ARRAY_TYPE(");

   321

  current_basetypedeclaration = arraybasetypeincl_bd;

   322

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

   323

  current_basetypedeclaration = none_bd;

   324

  s4o_incl.print(",");

   325

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

   326

  s4o_incl.print(",");

   327

  current_basetypedeclaration = arraysubrange_bd;

   328

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

   329

  current_basetypedeclaration = none_bd;

   330

  s4o_incl.print(")\n");

   331

   332

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

   333

    s4o.print("#define __CHECK_");

   334

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

   335

    s4o.print(" __CHECK_");

   336

    current_basetypedeclaration = arraybasetype_bd;

   337

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

   338

    current_basetypedeclaration = none_bd;

   339

    s4o.print("\n");

   340

  }

   341

   342

  current_type_name = symbol->identifier;

   343

  current_basetypedeclaration = arraytranslateindex_bd;

   344

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

   345

  current_basetypedeclaration = none_bd;

   346

  s4o.print("\n");

   347

   348

  return NULL;

   349

}

   350

   351

/* array_specification [ASSIGN array_initialization] */

   352

/* array_initialization may be NULL ! */

   353

void *visit(array_spec_init_c *symbol) {

   354

  TRACE("array_spec_init_c");

   355

   356

  identifier_c *array_type_name = dynamic_cast<identifier_c *>(symbol->array_specification);

   357

   358

  if (array_type_name == NULL) {

   359

    current_typedefinition = array_td;

   360

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

   361

    current_typedefinition = none_td;

   362

  }

   363

  else

   364

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

   365

  return NULL;

   366

}

   367

   368

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

   369

void *visit(array_specification_c *symbol) {

   370

  switch (current_basetypedeclaration) {

   371

    case arraybasetype_bd:

   372

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

   373

      break;

   374

    case arraybasetypeincl_bd:

   375

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

   376

      break;

   377

    case arraysubrange_bd:

   378

    case arraytranslateindex_bd:

   379

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

   380

      break;

   381

    default:

   382

      break;

   383

  }

   384

  return NULL;

   385

}

   386

   387

/* helper symbol for array_specification */

   388

/* array_subrange_list ',' subrange */

   389

void *visit(array_subrange_list_c *symbol) {

   390

  if (current_basetypedeclaration == arraytranslateindex_bd) {

   391

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

   392

      s4o.print("#define __");

   393

      current_type_name->accept(*this);

   394

      s4o.print("_TRANSIDX");

   395

      print_integer(i);

   396

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

   397

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

   398

      s4o.print("\n");

   399

    }

   400

  }

   401

  else

   402

    print_list(symbol);

   403

  return NULL;

   404

}

   405

   406

/*  TYPE type_declaration_list END_TYPE */

   407

void *visit(data_type_declaration_c *symbol) {

   408

  TRACE("data_type_declaration_c");

   409

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

   410

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

   411

  return NULL;

   412

}

   413

   414

/* helper symbol for data_type_declaration */

   415

void *visit(type_declaration_list_c *symbol) {

   416

  TRACE("type_declaration_list_c");

   417

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

   418

}

   419

   420

/*  simple_type_name ':' simple_spec_init */

   421

void *visit(simple_type_declaration_c *symbol) {

   422

  TRACE("simple_type_declaration_c");

   423

   424

  s4o_incl.print("__DECLARE_DERIVED_TYPE");

   425

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

   426

  s4o_incl.print(",");

   427

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

   428

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

   429

  return NULL;

   430

}

   431

   432

/* simple_specification [ASSIGN constant] */

   433

//SYM_REF2(simple_spec_init_c, simple_specification, constant)

   434

// <constant> may be NULL

   435

void *visit(simple_spec_init_c *symbol) {

   436

  TRACE("simple_spec_init_c");

   437

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

   438

  return NULL;

   439

}

   440

   441

#if 0

   442

/*  subrange_type_name ':' subrange_spec_init */

   443

SYM_REF2(subrange_type_declaration_c, subrange_type_name, subrange_spec_init)

   444

   445

/* subrange_specification ASSIGN signed_integer */

   446

SYM_REF2(subrange_spec_init_c, subrange_specification, signed_integer)

   447

   448

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

   449

SYM_REF2(subrange_specification_c, integer_type_name, subrange)

   450

   451

/*  signed_integer DOTDOT signed_integer */

   452

SYM_REF2(subrange_c, lower_limit, upper_limit)

   453

   454

/*  enumerated_type_name ':' enumerated_spec_init */

   455

SYM_REF2(enumerated_type_declaration_c, enumerated_type_name, enumerated_spec_init)

   456

   457

/* enumerated_specification ASSIGN enumerated_value */

   458

SYM_REF2(enumerated_spec_init_c, enumerated_specification, enumerated_value)

   459

   460

/* helper symbol for enumerated_specification->enumerated_spec_init */

   461

/* enumerated_value_list ',' enumerated_value */

   462

SYM_LIST(enumerated_value_list_c)

   463

   464

/* enumerated_type_name '#' identifier */

   465

SYM_REF2(enumerated_value_c, type, value)

   466

   467

/*  identifier ':' array_spec_init */

   468

SYM_REF2(array_type_declaration_c, identifier, array_spec_init)

   469

   470

/* array_specification [ASSIGN array_initialization} */

   471

/* array_initialization may be NULL ! */

   472

SYM_REF2(array_spec_init_c, array_specification, array_initialization)

   473

   474

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

   475

SYM_REF2(array_specification_c, array_subrange_list, non_generic_type_name)

   476

   477

/* helper symbol for array_specification */

   478

/* array_subrange_list ',' subrange */

   479

SYM_LIST(array_subrange_list_c)

   480

   481

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

   482

/* helper symbol for array_initialization */

   483

/* array_initial_elements_list ',' array_initial_elements */

   484

SYM_LIST(array_initial_elements_list_c)

   485

   486

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

   487

/* array_initial_element may be NULL ! */

   488

SYM_REF2(array_initial_elements_c, integer, array_initial_element)

   489

#endif

   490

   491

/*  structure_type_name ':' structure_specification */

   492

//SYM_REF2(structure_type_declaration_c, structure_type_name, structure_specification)

   493

void *visit(structure_type_declaration_c *symbol) {

   494

  TRACE("structure_type_declaration_c");

   495

   496

  s4o_incl.print("__DECLARE_STRUCT_TYPE(");

   497

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

   498

  s4o_incl.print(",");

   499

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

   500

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

   501

  return NULL;

   502

}