1

/*

     3

 *

     6

 *

    19

 *

    20

 * This code is made available on the understanding that it will not be

    21

 * used in safety-critical situations without a full and competent review.

    22

 *

    23

 * Based on the

    24

 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    25

 *

    26

 */

    27

    28

typedef struct

    29

{

    30

  symbol_c *symbol;

    31

} SYMBOL;

    32

    33

typedef enum {

    34

  none_lt,

    35

  input_lt,

    36

  output_lt,

    37

  memory_lt

    38

} locationtype_t;

    39

    40

    41

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

    42

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

    43

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

    44

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

    45

    46

    47

class search_location_type_c: public iterator_visitor_c {

    48

    49

  public:

    50

    locationtype_t current_location_type;

    51

    52

  public:

    53

	search_location_type_c(void) {}

    54

    55

	virtual ~search_location_type_c(void) {}

    56

    57

	locationtype_t get_location_type(symbol_c *symbol) {

    58

      current_location_type = none_lt;

    59

      symbol->accept(*this);

    60

      if (current_location_type == none_lt) ERROR;

    61

      return current_location_type;

    62

	}

    63

    64

  private:

    65

    66

	void *visit(incompl_location_c* symbol) {

    67

      if (symbol->value[1] == 'I')

    68

        current_location_type = input_lt;

    69

	  else if (symbol->value[1] == 'Q')

    70

        current_location_type = output_lt;

    71

	  else if (symbol->value[1] == 'M')

    72

        current_location_type = memory_lt;

    73

      return NULL;

    74

	}

    75

    76

	void *visit(direct_variable_c *symbol) {

    77

      if (symbol->value[1] == 'I')

    78

        current_location_type = input_lt;

    79

	  else if (symbol->value[1] == 'Q')

    80

        current_location_type = output_lt;

    81

	  else if (symbol->value[1] == 'M')

    82

        current_location_type = memory_lt;

    83

      return NULL;

    84

	}

    85

};

    86

    87

    88

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

    89

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

    90

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

    91

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

    92

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

    93

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

    94

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

    95

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

    96

    97

class generate_var_list_c: protected generate_c_typedecl_c {

    98

    99

  public:

   100

    typedef enum {

   101

      none_dt,

   102

      programs_dt,

   103

      variables_dt

   104

    } declarationtype_t;

   105

   106

    declarationtype_t current_declarationtype;

   107

   108

    typedef enum {

   109

      none_vtc,

   110

      variable_vtc,

   111

      external_vtc,

   112

      located_input_vtc,

   113

      located_output_vtc,

   114

      array_vtc,

   115

      structure_vtc,

   116

      function_block_vtc

   117

    } vartypecategory_t;

   118

   119

    vartypecategory_t current_var_type_category;

   120

   121

  private:

   122

    symbol_c *current_var_type_symbol;

   123

    symbol_c *current_var_type_name;

   124

    unsigned int current_var_number;

   125

    unsigned int step_number;

   126

    unsigned int transition_number;

   127

    unsigned int action_number;

   128

    bool configuration_defined;

   129

    std::list<SYMBOL> current_symbol_list;

   130

    search_base_type_c search_base_type;

   131

    search_fb_typedecl_c *search_fb_typedecl;

   132

   133

  public:

   134

    generate_var_list_c(stage4out_c *s4o_ptr, symbol_c *scope)

   135

    : generate_c_typedecl_c(s4o_ptr) {

   136

      search_fb_typedecl = new search_fb_typedecl_c(scope);

   137

      current_var_number = 0;

   138

      current_var_type_symbol = current_var_type_name = NULL;

   139

      current_declarationtype = none_dt;

   140

      current_var_type_category = none_vtc;

   141

    }

   142

   143

    ~generate_var_list_c(void) {

   144

      delete search_fb_typedecl;

   145

    }

   146

   147

    void update_var_type_symbol(symbol_c *symbol) {

   148

   149

      this->current_var_type_name = spec_init_sperator_c::get_spec(symbol);

   150

      if (this->current_var_type_name == NULL) {

   151

        std::list<SYMBOL>::iterator pt;

   152

        for(pt = current_symbol_list.begin(); pt != current_symbol_list.end(); pt++) {

   153

          fprintf(stderr, "%s.", ((identifier_c*)(pt->symbol))->value);

   154

        }

   155

        ERROR;

   156

      }

   157

   158

      this->current_var_type_symbol = search_fb_typedecl->get_decl(this->current_var_type_name);

   159

      if (this->current_var_type_symbol != NULL)

   160

        this->current_var_type_category = function_block_vtc;

   161

      else {

   162

        this->current_var_type_symbol = (symbol_c *)(this->current_var_type_name->accept(search_base_type));

   163

   164

        structure_element_declaration_list_c *structure_symbol = dynamic_cast<structure_element_declaration_list_c *>(this->current_var_type_symbol);

   165

        if (structure_symbol != NULL)

   166

          this->current_var_type_category = structure_vtc;

   167

        else

   168

          this->current_var_type_category = variable_vtc;

   169

      }

   170

   171

      if (this->current_var_type_symbol == NULL)

   172

        ERROR;

   173

    }

   174

   175

    void reset_var_type_symbol(void) {

   176

      this->current_var_type_symbol = NULL;

   177

    }

   178

   179

    void generate_programs(symbol_c *symbol) {

   180

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

   181

      current_var_number = 0;

   182

      configuration_defined = false;

   183

      current_declarationtype = programs_dt;

   184

      symbol->accept(*this);

   185

      current_declarationtype = none_dt;

   186

      s4o.print("\n");

   187

    }

   188

   189

    void generate_variables(symbol_c *symbol) {

   190

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

   191

      current_var_number = 0;

   192

      configuration_defined = false;

   193

      current_declarationtype = variables_dt;

   194

      symbol->accept(*this);

   195

      current_declarationtype = none_dt;

   196

      s4o.print("\n");

   197

    }

   198

   199

    void declare_variables(symbol_c *symbol) {

   200

      list_c *list = dynamic_cast<list_c *>(symbol);

   201

      /* should NEVER EVER occur!! */

   202

      if (list == NULL) ERROR;

   203

   204

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

   205

        declare_variable(list->elements[i]);

   206

      }

   207

    }

   208

   209

    void declare_variable(symbol_c *symbol) {

   210

      print_var_number();

   211

      s4o.print(";");

   212

      switch (this->current_var_type_category) {

   213

        case external_vtc:

   214

          s4o.print("EXT");

   215

          break;

   216

        case located_input_vtc:

   217

          s4o.print("IN");

   218

          break;

   219

        case located_output_vtc:

   220

          s4o.print("OUT");

   221

          break;

   222

        case array_vtc:

   223

          s4o.print("ARRAY");

   224

          break;

   225

        case structure_vtc:

   226

          s4o.print("STRUCT");

   227

          break;

   228

        case function_block_vtc:

   229

          s4o.print("FB");

   230

          break;

   231

        default:

   232

          s4o.print("VAR");

   233

          break;

   234

      }

   235

      s4o.print(";");

   236

      print_symbol_list();

   237

      symbol->accept(*this);

   238

      s4o.print(";");

   239

      print_symbol_list();

   240

      symbol->accept(*this);

   241

      s4o.print(";");

   242

      switch (this->current_var_type_category) {

   243

        case structure_vtc:

   244

        case function_block_vtc:

   245

          this->current_var_type_name->accept(*this);

   246

          s4o.print(";\n");

   247

          SYMBOL *current_name;

   248

          current_name = new SYMBOL;

   249

          current_name->symbol = symbol;

   250

          current_symbol_list.push_back(*current_name);

   251

          this->current_var_type_symbol->accept(*this);

   252

          current_symbol_list.pop_back();

   253

          break;

   254

        case array_vtc:

   255

          this->current_var_type_name->accept(*this);

   256

          s4o.print(";\n");

   257

          break;

   258

        default:

   259

          this->current_var_type_symbol->accept(*this);

   260

          s4o.print(";\n");

   261

          break;

   262

      }

   263

    }

   264

   265

    void print_var_number(void) {

   266

      char str[10];

   267

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

   268

      s4o.print(str);

   269

      current_var_number++;

   270

    }

   271

   272

    void print_step_number(void) {

   273

      char str[10];

   274

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

   275

      s4o.print(str);

   276

    }

   277

   278

    void print_transition_number(void) {

   279

      char str[10];

   280

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

   281

      s4o.print(str);

   282

    }

   283

   284

    void print_action_number(void) {

   285

      char str[10];

   286

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

   287

      s4o.print(str);

   288

    }

   289

   290

    void print_symbol_list(void) {

   291

      std::list<SYMBOL>::iterator pt;

   292

      for(pt = current_symbol_list.begin(); pt != current_symbol_list.end(); pt++) {

   293

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

   294

        s4o.print(".");

   295

      }

   296

    }

   297

   298

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

   299

/* B.1.4.3 - Declaration and initialization */

   300

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

   301

   302

    /*  [variable_name] location ':' located_var_spec_init */

   303

    /* variable_name -> may be NULL ! */

   304

    //SYM_REF4(located_var_decl_c, variable_name, location, located_var_spec_init, unused)

   305

    void *visit(located_var_decl_c *symbol) {

   306

        /* Start off by setting the current_var_type_symbol and

   307

         * current_var_init_symbol private variables...

   308

         */

   309

        update_var_type_symbol(symbol->located_var_spec_init);

   310

   311

        search_location_type_c search_location_type;

   312

        locationtype_t location_type = search_location_type.get_location_type(symbol->location);

   313

        if (location_type == input_lt)

   314

          this->current_var_type_category = located_input_vtc;

   315

        else if (location_type == output_lt)

   316

          this->current_var_type_category = located_output_vtc;

   317

   318

        if (symbol->variable_name != NULL)

   319

          declare_variable(symbol->variable_name);

   320

        else

   321

          declare_variable(symbol->location);

   322

   323

        current_var_type_symbol = NULL;

   324

        return NULL;

   325

    }

   326

   327

    /* variable_name incompl_location ':' var_spec */

   328

    /* variable_name -> may be NULL ! */

   329

    //SYM_REF3(incompl_located_var_decl_c, variable_name, incompl_location, var_spec)

   330

    void *visit(incompl_located_var_decl_c *symbol) {

   331

        /* Start off by setting the current_var_type_symbol and

   332

         * current_var_init_symbol private variables...

   333

         */

   334

        update_var_type_symbol(symbol->var_spec);

   335

   336

        search_location_type_c search_location_type;

   337

        locationtype_t location_type = search_location_type.get_location_type(symbol->incompl_location);

   338

        if (location_type == input_lt)

   339

          this->current_var_type_category = located_input_vtc;

   340

        else if (location_type == output_lt)

   341

          this->current_var_type_category = located_output_vtc;

   342

   343

        if (symbol->variable_name != NULL)

   344

          declare_variable(symbol->variable_name);

   345

        else

   346

          declare_variable(symbol->incompl_location);

   347

   348

        current_var_type_symbol = NULL;

   349

        return NULL;

   350

    }

   351

   352

    /*  var1_list ':' array_spec_init */

   353

    // SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   354

    void *visit(array_var_init_decl_c *symbol) {

   355

      TRACE("array_var_init_decl_c");

   356

      /* Start off by setting the current_var_type_symbol and

   357

       * current_var_init_symbol private variables...

   358

       */

   359

      update_var_type_symbol(symbol->array_spec_init);

   360

   361

      this->current_var_type_category = array_vtc;

   362

      //declare_variables(symbol->var1_list);

   363

   364

      /* Values no longer in scope, and therefore no longer used.

   365

       * Make an effort to keep them set to NULL when not in use

   366

       * in order to catch bugs as soon as possible...

   367

       */

   368

      reset_var_type_symbol();

   369

   370

      return NULL;

   371

    }

   372

   373

    /*  var1_list ':' initialized_structure */

   374

    // SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure)

   375

    void *visit(structured_var_init_decl_c *symbol) {

   376

      TRACE("structured_var_init_decl_c");

   377

      /* Please read the comments inside the var1_init_decl_c

   378

       * visitor, as they apply here too.

   379

       */

   380

   381

      /* Start off by setting the current_var_type_symbol and

   382

       * current_var_init_symbol private variables...

   383

       */

   384

      update_var_type_symbol(symbol->initialized_structure);

   385

   386

      /* now to produce the c equivalent... */

   387

      //declare_variables(symbol->var1_list);

   388

   389

      /* Values no longer in scope, and therefore no longer used.

   390

       * Make an effort to keep them set to NULL when not in use

   391

       * in order to catch bugs as soon as possible...

   392

       */

   393

      reset_var_type_symbol();

   394

   395

      return NULL;

   396

    }

   397

   398

    /* fb_name_list ':' function_block_type_name ASSIGN structure_initialization */

   399

    /* structure_initialization -> may be NULL ! */

   400

    void *visit(fb_name_decl_c *symbol) {

   401

      TRACE("fb_name_decl_c");

   402

      /* Please read the comments inside the var1_init_decl_c

   403

       * visitor, as they apply here too.

   404

       */

   405

   406

      /* Start off by setting the current_var_type_symbol and

   407

       * current_var_init_symbol private variables...

   408

       */

   409

      update_var_type_symbol(symbol);

   410

   411

      /* now to produce the c equivalent... */

   412

      declare_variables(symbol->fb_name_list);

   413

   414

      /* Values no longer in scope, and therefore no longer used.

   415

       * Make an effort to keep them set to NULL when not in use

   416

       * in order to catch bugs as soon as possible...

   417

       */

   418

      reset_var_type_symbol();

   419

   420

      return NULL;

   421

    }

   422

   423

    /*  global_var_name ':' (simple_specification|subrange_specification|enumerated_specification|array_specification|prev_declared_structure_type_name|function_block_type_name */

   424

    //SYM_REF2(external_declaration_c, global_var_name, specification)

   425

    void *visit(external_declaration_c *symbol) {

   426

      TRACE("external_declaration_c");

   427

      /* Please read the comments inside the var1_init_decl_c

   428

       * visitor, as they apply here too.

   429

       */

   430

   431

      /* Start off by setting the current_var_type_symbol and

   432

       * current_var_init_symbol private variables...

   433

       */

   434

      update_var_type_symbol(symbol->specification);

   435

   436

      /* now to produce the c equivalent... */

   437

      this->current_var_type_category = external_vtc;

   438

      declare_variable(symbol->global_var_name);

   439

   440

      /* Values no longer in scope, and therefore no longer used.

   441

       * Make an effort to keep them set to NULL when not in use

   442

       * in order to catch bugs as soon as possible...

   443

       */

   444

      reset_var_type_symbol();

   445

   446

      return NULL;

   447

    }

   448

   449

    /*| global_var_spec ':' [located_var_spec_init|function_block_type_name] */

   450

    /* type_specification ->may be NULL ! */

   451

    // SYM_REF2(global_var_decl_c, global_var_spec, type_specification)

   452

    void *visit(global_var_decl_c *symbol) {

   453

      TRACE("global_var_decl_c");

   454

      /* Please read the comments inside the var1_init_decl_c

   455

       * visitor, as they apply here too.

   456

       */

   457

   458

      /* Start off by setting the current_var_type_symbol and

   459

       * current_var_init_symbol private variables...

   460

       */

   461

      update_var_type_symbol(symbol->type_specification);

   462

   463

      /* now to produce the c equivalent... */

   464

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

   465

   466

      /* Values no longer in scope, and therefore no longer used.

   467

       * Make an effort to keep them set to NULL when not in use

   468

       * in order to catch bugs as soon as possible...

   469

       */

   470

      reset_var_type_symbol();

   471

   472

      return NULL;

   473

    }

   474

   475

    void *visit(global_var_list_c *symbol) {

   476

      declare_variables(symbol);

   477

      return NULL;

   478

    }

   479

   480

    /*| global_var_name location */

   481

    // SYM_REF2(global_var_spec_c, global_var_name, location)

   482

    void *visit(global_var_spec_c *symbol) {

   483

      search_location_type_c search_location_type;

   484

	  locationtype_t location_type = search_location_type.get_location_type(symbol->location);

   485

	  if (location_type == input_lt)

   486

        this->current_var_type_category = located_input_vtc;

   487

      else if (location_type == output_lt)

   488

        this->current_var_type_category = located_output_vtc;

   489

   490

      if (symbol->global_var_name != NULL)

   491

        declare_variable(symbol->global_var_name);

   492

      else

   493

        declare_variable(symbol->location);

   494

      return NULL;

   495

    }

   496

   497

    void *visit(var1_init_decl_c *symbol) {

   498

      TRACE("var1_init_decl_c");

   499

   500

      /* Start off by setting the current_var_type_symbol and

   501

       * current_var_init_symbol private variables...

   502

       */

   503

      update_var_type_symbol(symbol->spec_init);

   504

   505

      /* now to produce the c equivalent... */

   506

      declare_variables(symbol->var1_list);

   507

   508

      /* Values no longer in scope, and therefore no longer used.