1

/*

     2

 *  matiec - a compiler for the programming languages defined in IEC 61131-3

     3

 *

     4

 *  Copyright (C) 2009-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

    25

/*

    26

 * An IEC 61131-3 compiler.

    27

 *

    28

 * Based on the

    29

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

    30

 *

    31

 */

    32

    33

    34

/*

    35

 * Iterate through all declared functions and Function Blocks, 

    36

 * and, for each function/FB, add a declaration of the EN and ENO 

    37

 * parameters, if they have not already been explicitly declared.

    38

 *

    39

 * EN and ENO parameters declared explicitly (by the user in the source code)

    40

 * and implicitly (by the comnpiler, i.e. by this visitor class) may be

    41

 * distinguished later on by the 'method' flag in the en_param_declaration_c

    42

 * and eno_param_declaration_c objects.

    43

 */

    44

    45

#include "add_en_eno_param_decl.hh"

    46

#include <strings.h>

    47

#include "../main.hh" // required for ERROR() and ERROR_MSG() macros.

    48

    49

    50

// #define DEBUG

    51

#ifdef DEBUG

    52

#define TRACE(classname) printf("\n____%s____\n",classname);

    53

#else

    54

#define TRACE(classname)

    55

#endif

    56

    57

    58

    59

    60

    61

/* This class is a singleton.

    62

 * So we need a pointer to the singe instance...

    63

 */

    64

add_en_eno_param_decl_c *add_en_eno_param_decl_c::singleton = NULL;

    65

    66

/* Constructor for the singleton class */

    67

symbol_c *add_en_eno_param_decl_c::add_to(symbol_c *tree_root) {

    68

      if (NULL == singleton) {

    69

        singleton = new add_en_eno_param_decl_c;

    70

        if (NULL == singleton)

    71

          return NULL;

    72

      }

    73

      tree_root->accept(*singleton);

    74

      return tree_root;

    75

    }

    76

    77

/* Destructor for the singleton class */

    78

add_en_eno_param_decl_c::~add_en_eno_param_decl_c(void) {

    79

      if (NULL != singleton) delete singleton;

    80

      singleton = NULL;

    81

    }

    82

    83

    84

    85

void* add_en_eno_param_decl_c::iterate_list(list_c *list) {

    86

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

    88

  }

    89

  return NULL;

    90

}

    91

    92

    93

input_declarations_c *add_en_eno_param_decl_c::build_en_param(void) {

    94

  boolean_literal_c  *boolean_literal = new boolean_literal_c(new bool_type_name_c(), new boolean_true_c());

    95

  identifier_c       *identifier      = new identifier_c("EN");

    96

  simple_spec_init_c *type_spec_init  = new simple_spec_init_c(new bool_type_name_c(), boolean_literal);

    97

  en_param_declaration_c *en_param_declaration = 

    98

    new en_param_declaration_c(identifier, type_spec_init, new implicit_definition_c());

    99

    /* the last paramater is to flag that this

   100

     * declaration was inserted automatically, i.e. an implicit declaration 

   101

     */

   102

  input_declaration_list_c *input_declaration_list = new input_declaration_list_c();

   103

  input_declaration_list->add_element(en_param_declaration);

   104

   105

  input_declarations_c *input_declarations = new input_declarations_c(NULL, input_declaration_list, new implicit_definition_c());

   106

  return input_declarations;

   107

}

   108

   109

   110

output_declarations_c *add_en_eno_param_decl_c::build_eno_param(void) {

   111

  identifier_c *identifier = new identifier_c("ENO");

   112

  eno_param_declaration_c *eno_param_declaration =

   113

    new eno_param_declaration_c(identifier, new bool_type_name_c(), new implicit_definition_c()); 

   114

    /* the last paramater is to flag that this

   115

     * declaration was inserted automatically, i.e. an implicit declaration 

   116

     */

   117

  var_init_decl_list_c *var_init_decl_list = new var_init_decl_list_c();

   118

  var_init_decl_list->add_element(eno_param_declaration);

   119

   120

  output_declarations_c *output_declarations = new output_declarations_c(NULL, var_init_decl_list, new implicit_definition_c());

   121

  return output_declarations;

   122

}

   123

   124

   125

   126

   127

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

   128

/* B 0 - Programming Model */

   129

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

   130

void *add_en_eno_param_decl_c::visit(library_c *symbol) {

   131

  TRACE("library_c"); 

   132

  return iterate_list(symbol);

   133

}

   134

   135

   136

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

   137

/* B 1.5.1 - Functions */

   138

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

   139

void *add_en_eno_param_decl_c::visit(function_declaration_c *symbol) {

   140

  TRACE("function_declaration_c"); 

   141

  return symbol->var_declarations_list->accept(*this);

   142

}

   143

   144

void *add_en_eno_param_decl_c::visit(var_declarations_list_c *symbol) {

   145

    TRACE("var_declarations_list_c");

   146

    en_declared  = false; 

   147

    eno_declared = false; 

   148

    iterate_list(symbol);

   149

    /* insert elements to begining of list! */

   150

    /* We want EN first, and then ENO.

   151

     * But, since we are insertin them into the head of the list, we must insert EN last so it will stay in the first position!

   152

     */

   153

    if(eno_declared == false) symbol->insert_element(build_eno_param());

   154

    if(en_declared  == false) symbol->insert_element(build_en_param());

   155

    /* append elements to end of list! */

   156

    /*

   157

    if(en_declared  == false) symbol->add_element(build_en_param());

   158

    if(eno_declared == false) symbol->add_element(build_eno_param());

   159

    */

   160

    return NULL;

   161

}

   162

   163

   164

   165

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

   166

/* 1.4.3 - Declaration & Initialisation */

   167

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

   168

void *add_en_eno_param_decl_c::visit(input_declarations_c *symbol) {

   169

  TRACE("input_declarations_c");

   170

//   current_param_direction = direction_in;

   171

  return symbol->input_declaration_list->accept(*this);

   172

}

   173

   174

void *add_en_eno_param_decl_c::visit(input_declaration_list_c *symbol) {TRACE("input_declaration_list_c"); return iterate_list(symbol);}

   175

   176

void *add_en_eno_param_decl_c::visit(en_param_declaration_c *symbol) {

   177

  TRACE("en_param_declaration_c");

   178

  en_declared = true;

   179

  return NULL;

   180

}

   181

   182

void *add_en_eno_param_decl_c::visit(eno_param_declaration_c *symbol) {

   183

  TRACE("eno_param_declaration_c");

   184

  eno_declared = true;

   185

  return NULL;

   186

}

   187

   188

void *add_en_eno_param_decl_c::visit(output_declarations_c *symbol) {

   189

  TRACE("output_declarations_c");

   190

//   current_param_direction = direction_out;

   191

  return symbol->var_init_decl_list->accept(*this);

   192

}

   193

   194

void *add_en_eno_param_decl_c::visit(var_init_decl_list_c *symbol) 

   195

{TRACE("var_init_decl_list_c"); return iterate_list(symbol);}

   196

   197

   198

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

   199

/* B 1.5.2 - Function Blocks */

   200

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

   201

/*  FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */

   202

void *add_en_eno_param_decl_c::visit(function_block_declaration_c *symbol) {

   203

  TRACE("function_block_declaration_c"); 

   204

  return symbol->var_declarations->accept(*this);

   205

}

   206

   207

   208

   209