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

    48

    49

// #define DEBUG

    50

#ifdef DEBUG

    51

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

    52

#else

    53

#define TRACE(classname)

    54

#endif

    55

    56

    57

#define ERROR error_exit(__FILE__,__LINE__)

    58

/* function defined in main.cc */

    59

extern void error_exit(const char *file_name, int line_no);

    60

    61

    62

    63

/* This class is a singleton.

    64

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

    65

 */

    66

add_en_eno_param_decl_c *add_en_eno_param_decl_c::singleton = NULL;

    67

    68

/* Constructor for the singleton class */

    69

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

    70

      if (NULL == singleton) {

    71

        singleton = new add_en_eno_param_decl_c;

    72

        if (NULL == singleton)

    73

          return NULL;

    74

      }

    75

      tree_root->accept(*singleton);

    76

      return tree_root;

    77

    }

    78

    79

/* Destructor for the singleton class */

    80

add_en_eno_param_decl_c::~add_en_eno_param_decl_c(void) {

    81

      if (NULL != singleton) delete singleton;

    82

      singleton = NULL;

    83

    }

    84

    85

    86

    87

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

    88

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

    89

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

    90

  }

    91

  return NULL;

    92

}

    93

    94

    95

input_declarations_c *add_en_eno_param_decl_c::build_en_param(void) {

    96

  boolean_literal_c *boolean_literal = 

    97

    new boolean_literal_c(new bool_type_name_c(), new boolean_true_c());

    98

  identifier_c *identifier =

    99

    new identifier_c("EN");

   100

  en_param_declaration_c *en_param_declaration = 

   101

    new en_param_declaration_c(identifier, new bool_type_name_c(), boolean_literal, new implicit_definition_c());

   102

    /* the last paramater is to flag that this

   103

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

   104

     */

   105

  input_declaration_list_c *input_declaration_list = new input_declaration_list_c();

   106

  input_declaration_list->add_element(en_param_declaration);

   107

   108

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

   109

  return input_declarations;

   110

}

   111

   112

   113

output_declarations_c *add_en_eno_param_decl_c::build_eno_param(void) {

   114

  identifier_c *identifier =

   115

    new identifier_c("ENO");

   116

  eno_param_declaration_c *eno_param_declaration =

   117

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

   118

    /* the last paramater is to flag that this

   119

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

   120

     */

   121

  var_init_decl_list_c *var_init_decl_list = new var_init_decl_list_c();

   122

  var_init_decl_list->add_element(eno_param_declaration);

   123

   124

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

   125

  return output_declarations;

   126

}

   127

   128

   129

   130

   131

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

   132

/* B 0 - Programming Model */

   133

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

   134

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

   135

  TRACE("library_c"); 

   136

  return iterate_list(symbol);

   137

}

   138

   139

   140

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

   141

/* B 1.5.1 - Functions */

   142

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

   143

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

   144

  TRACE("function_declaration_c"); 

   145

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

   146

}

   147

   148

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

   149

    TRACE("var_declarations_list_c");

   150

    en_declared  = false; 

   151

    eno_declared = false; 

   152

    iterate_list(symbol);

   153

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

   154

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

   155

    return NULL;

   156

}

   157

   158

   159

   160

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

   161

/* 1.4.3 - Declaration & Initialisation */

   162

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

   163

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

   164

  TRACE("input_declarations_c");

   165

//   current_param_direction = direction_in;

   166

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

   167

}

   168

   169

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

   170

   171

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

   172

  TRACE("en_param_declaration_c");

   173

  en_declared = true;

   174

  return NULL;

   175

}

   176

   177

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

   178

  TRACE("eno_param_declaration_c");

   179

  eno_declared = true;

   180

  return NULL;

   181

}

   182

   183

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

   184

  TRACE("output_declarations_c");

   185

//   current_param_direction = direction_out;

   186

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

   187

}

   188

   189

void *add_en_eno_param_decl_c::visit(var_init_decl_list_c *symbol) 

   190

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

   191

   192

   193

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

   194

/* B 1.5.2 - Function Blocks */

   195

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

   196

/*  FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */

   197

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

   198

  TRACE("function_block_declaration_c"); 

   199

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

   200

}

   201

   202

   203

   204