1

/*

     2

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

     3

 *

     4

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

/* Decomposes a variable instance name into its constituents,

    35

 * example:

    36

 *    window.points[1].coordinate.x

    37

 *

    38

 *  will succesfully return

    39

 *        - window

    40

 *        - points

    41

 *        - coordinate

    42

 *        - x

    43

 * on succesive calls to decompose_var_instance_name_c::next_part()

    44

 */

    45

    46

    47

    48

#include "decompose_var_instance_name.hh"

    49

    50

decompose_var_instance_name_c::decompose_var_instance_name_c(symbol_c *variable_instance_name) {

    51

  variable_name = variable_instance_name;

    52

  next_variable_name = NULL;

    53

  current_recursive_variable_name = NULL;

    54

  previously_returned_variable_name = NULL;

    55

  current_array_subscript_list = NULL;

    56

}

    57

    58

/* Get the next element in the strcutured variable */

    59

symbol_c *decompose_var_instance_name_c::get_next() {

    60

  /* We must always start from the top!

    61

   * See note in the structured_variable_c visitor

    62

   * to understand why...

    63

   */

    64

  current_array_subscript_list = NULL;

    65

  symbol_c *res = (symbol_c *)variable_name->accept(*this);

    66

  next_variable_name = current_recursive_variable_name;

    67

    68

  if (previously_returned_variable_name == res)

    69

    return NULL;

    70

    71

  previously_returned_variable_name = res;

    72

  return res;

    73

}

    74

    75

/* If the current element in the structured variable is an array, return its subscript_list, 

    76

 * otherwise return NULL

    77

 */

    78

list_c *decompose_var_instance_name_c::get_current_arraysubs_list(void) {return current_array_subscript_list;}

    79

    80

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

    81

/* B.1 - Common elements */

    82

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

    83

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

    84

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

    85

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

    86

/* sometimes (e.g. FB calls) the name of the variable is stored directly in an identifier_c object */

    87

void *decompose_var_instance_name_c::visit(identifier_c *symbol) {return (void *)symbol;}

    88

    89

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

    90

/* B 1.4 - Variables */

    91

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

    92

void *decompose_var_instance_name_c::visit(symbolic_variable_c *symbol) {return (void *)(symbol->var_name);}

    93

    94

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

    95

/* B.1.4.1   Directly Represented Variables */

    96

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

    97

void *decompose_var_instance_name_c::visit(direct_variable_c *symbol) {return (void *)symbol;}

    98

    99

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

   100

/* B.1.4.2   Multi-element Variables */

   101

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

   102

/*  subscripted_variable '[' subscript_list ']' */

   103

// SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   104

void *decompose_var_instance_name_c::visit(array_variable_c *symbol) {

   105

  if (NULL == symbol->subscript_list) ERROR; // array may not have an empty subscript list!

   106

  current_array_subscript_list = dynamic_cast<list_c *>(symbol->subscript_list);

   107

  if (NULL == current_array_subscript_list) ERROR; // if it does not point to a subscript_list_c, then the abstract syntax tree has been changed, and this code needs to be fixed accordingly!

   108

   109

  /* NOTE: the subscripted_variable may itself be a structure or an array!, so we must recursevily visit! */

   110

  /* the next line will call either:

   111

   *   - visit(structured_variable_c *) or visit(array_variable_c *), if the array variable is itself an element of another array os structure

   112

   *   - visit(symbolic_variable_c *) if it is a simple array variable

   113

   */

   114

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

   115

}

   116

   117

/*  record_variable '.' field_selector */

   118

/*  WARNING: input and/or output variables of function blocks

   119

 *           may be accessed as fields of a tructured variable!

   120

 *           Code handling a structured_variable_c must take

   121

 *           this into account!

   122

 */

   123

//SYM_REF2(structured_variable_c, record_variable, field_selector)

   124

void *decompose_var_instance_name_c::visit(structured_variable_c *symbol) {

   125

  /* NOTE: The following code will not work, as structured_variable_c

   126

   *       are grouped on the left, and not on the right!

   127

   *

   128

   *       example: window.origin.x

   129

   *       will result in

   130

   *       s1 = structured_variable_c("window, "origin");

   131

   *       s2 = structured_variable_c(s1, "x");

   132

   *       AND NOT

   133

   *       s1 = structured_variable_c("origin", "x");

   134

   *       s2 = structured_variable_c("window", s1);

   135

   *

   136

   *       as the following code assumes!!

   137

   *

   138

  current_variable_name = symbol->field_selector;

   139

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

   140

   */

   141

   142

  /* The correct code, is therefore more complex... */

   143

  if (next_variable_name == symbol) {

   144

    return (void *)symbol->field_selector->accept(*this);

   145

  }

   146

   147

  current_array_subscript_list = NULL;

   148

  current_recursive_variable_name = symbol;

   149

  /* the next line will call either:

   150

   *   - visit(structured_variable_c *) or visit(array_variable_c *), if the record variable has more elements to visit

   151

   *   - visit(symbolic_variable_c *) if it is the last element in the record variable

   152

   */

   153

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

   154

}

   155

   156

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

   157

/* B 2.2 - Operators */

   158

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

   159

void *decompose_var_instance_name_c::visit(LD_operator_c *symbol) {return (void *)&LD_operator_name;}

   160

void *decompose_var_instance_name_c::visit(S_operator_c *symbol) {return (void *)&S_operator_name;}

   161

void *decompose_var_instance_name_c::visit(R_operator_c *symbol) {return (void *)&R_operator_name;}

   162

void *decompose_var_instance_name_c::visit(S1_operator_c *symbol) {return (void *)&S1_operator_name;}

   163

void *decompose_var_instance_name_c::visit(R1_operator_c *symbol) {return (void *)&R1_operator_name;}

   164

void *decompose_var_instance_name_c::visit(CLK_operator_c *symbol) {return (void *)&CLK_operator_name;}

   165

void *decompose_var_instance_name_c::visit(CU_operator_c *symbol) {return (void *)&CU_operator_name;}

   166

void *decompose_var_instance_name_c::visit(CD_operator_c *symbol) {return (void *)&CD_operator_name;}

   167

void *decompose_var_instance_name_c::visit(PV_operator_c *symbol) {return (void *)&PV_operator_name;}

   168

void *decompose_var_instance_name_c::visit(IN_operator_c *symbol) {return (void *)&IN_operator_name;}

   169

void *decompose_var_instance_name_c::visit(PT_operator_c *symbol) {return (void *)&PT_operator_name;}

   170

   171

identifier_c     decompose_var_instance_name_c::LD_operator_name("LD");

   172

identifier_c     decompose_var_instance_name_c::S_operator_name("S");

   173

identifier_c     decompose_var_instance_name_c::R_operator_name("R");

   174

identifier_c     decompose_var_instance_name_c::S1_operator_name("S1");

   175

identifier_c     decompose_var_instance_name_c::R1_operator_name("R1");

   176

identifier_c     decompose_var_instance_name_c::CLK_operator_name("CLK");

   177

identifier_c     decompose_var_instance_name_c::CU_operator_name("CU");

   178

identifier_c     decompose_var_instance_name_c::CD_operator_name("CD");

   179

identifier_c     decompose_var_instance_name_c::PV_operator_name("PV");

   180

identifier_c     decompose_var_instance_name_c::IN_operator_name("IN");

   181

identifier_c     decompose_var_instance_name_c::PT_operator_name("PT");

   182

   183