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

 *

     6

 *  This program is free software: you can redistribute it and/or modify

     7

 *  it under the terms of the GNU General Public License as published by

     8

 *  the Free Software Foundation, either version 3 of the License, or

     9

 *  (at your option) any later version.

    10

 *

    11

 *  This program is distributed in the hope that it will be useful,

    12

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    13

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    14

 *  GNU General Public License for more details.

    15

 *

    16

 *  You should have received a copy of the GNU General Public License

    17

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

    18

 *

    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

    24

/*

    25

 * An IEC 61131-3 compiler.

    26

 *

    27

 * Based on the

    28

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

    29

 *

    30

 */

    31

    32

    33

/*

    34

 * Iterate through all declared functions and Function Blocks, 

    35

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

    36

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

    37

 *

    38

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

    39

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

    40

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

    41

 * and eno_param_declaration_c objects.

    42

 */

    43

    44

#include "add_en_eno_param_decl.hh"

    45

#include <strings.h>

    46

    47

    48

// #define DEBUG

    49

#ifdef DEBUG

    50

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

    51

#else

    52

#define TRACE(classname)

    53

#endif

    54

    55

    56

#define ERROR error_exit(__FILE__,__LINE__)

    57

/* function defined in main.cc */

    58

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

    59

    60

    61

    62

/* This class is a singleton.

    63

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

    64

 */

    65

add_en_eno_param_decl_c *add_en_eno_param_decl_c::singleton = NULL;

    66

    67

/* Constructor for the singleton class */

    68

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

    69

      if (NULL == singleton) {

    70

        singleton = new add_en_eno_param_decl_c;

    71

        if (NULL == singleton)

    72

          return NULL;

    73

      }

    74

      tree_root->accept(*singleton);

    75

      return tree_root;

    76

    }

    77

    78

/* Destructor for the singleton class */

    79

add_en_eno_param_decl_c::~add_en_eno_param_decl_c(void) {

    80

      if (NULL != singleton) delete singleton;

    81

      singleton = NULL;

    82

    }

    83

    84

    85

    86

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

    87

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

    88

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

    89

  }

    90

  return NULL;

    91

}

    92

    93

    94

input_declarations_c *add_en_eno_param_decl_c::build_en_param(void) {

    95

  boolean_literal_c *boolean_literal = 

    96

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

    97

  identifier_c *identifier =

    98

    new identifier_c("EN");

    99

  en_param_declaration_c *en_param_declaration = 

   100

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

   101

    /* the last paramater is to flag that this

   102

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

   103

     */

   104

  input_declaration_list_c *input_declaration_list = new input_declaration_list_c();

   105

  input_declaration_list->add_element(en_param_declaration);

   106

   107

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

   108

  return input_declarations;

   109

}

   110

   111

   112

output_declarations_c *add_en_eno_param_decl_c::build_eno_param(void) {

   113

  identifier_c *identifier =

   114

    new identifier_c("ENO");

   115

  eno_param_declaration_c *eno_param_declaration =

   116

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

   117

    /* the last paramater is to flag that this

   118

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

   119

     */

   120

  var_init_decl_list_c *var_init_decl_list = new var_init_decl_list_c();

   121

  var_init_decl_list->add_element(eno_param_declaration);

   122

   123

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

   124

  return output_declarations;

   125

}

   126

   127

   128

   129

   130

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

   131

/* B 0 - Programming Model */

   132

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

   133

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

   134

  TRACE("library_c"); 

   135

  return iterate_list(symbol);

   136

}

   137

   138

   139

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

   140

/* B 1.5.1 - Functions */

   141

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

   142

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

   143

  TRACE("function_declaration_c"); 

   144

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

   145

}

   146

   147

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

   148

    TRACE("var_declarations_list_c");

   149

    en_declared  = false; 

   150

    eno_declared = false; 

   151

    iterate_list(symbol);

   152

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

   153

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

   154

    return NULL;

   155

}

   156

   157

   158

   159

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

   160

/* 1.4.3 - Declaration & Initialisation */

   161

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

   162

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

   163

  TRACE("input_declarations_c");

   164

//   current_param_direction = direction_in;

   165

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

   166

}

   167

   168

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

   169

   170

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

   171

  TRACE("en_param_declaration_c");

   172

  en_declared = true;

   173

  return NULL;

   174

}

   175

   176

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

   177

  TRACE("eno_param_declaration_c");

   178

  eno_declared = true;

   179

  return NULL;

   180

}

   181

   182

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

   183

  TRACE("output_declarations_c");

   184

//   current_param_direction = direction_out;

   185

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

   186

}

   187

   188

void *add_en_eno_param_decl_c::visit(var_init_decl_list_c *symbol) 

   189

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

   190

   191

   192

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

   193

/* B 1.5.2 - Function Blocks */

   194

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

   195

/*  FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */

   196

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

   197

  TRACE("function_block_declaration_c"); 

   198

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

   199

}

   200

   201

   202

   203