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

class generate_location_list_c: public iterator_visitor_c {

    26

    27

  protected:

    28

    stage4out_c &s4o;

    29

    30

  private:

    31

    symbol_c *current_var_type_symbol;

    32

    generate_c_base_c *generate_c_base;

    33

    search_base_type_c search_base_type;

    34

    35

  public:

    36

    generate_location_list_c(stage4out_c *s4o_ptr): s4o(*s4o_ptr) {

    37

      generate_c_base = new generate_c_base_c(s4o_ptr);

    38

      current_var_type_symbol = NULL;

    39

    }

    40

    ~generate_location_list_c(void) {

    41

      delete generate_c_base;

    42

    }

    43

    44

    bool test_location_type(symbol_c *direct_variable) {

    45

    46

      token_c *location = dynamic_cast<token_c *>(direct_variable);

    47

    48

      if (location == NULL)

    49

        /* invalid identifiers... */

    50

        return false;

    51

    52

      switch (location->value[2]) {

    53

        case 'X': // bit

    54

          if (typeid(*current_var_type_symbol) == typeid(bool_type_name_c)) return true;

    55

          break;

    56

        case 'B': // Byte, 8 bits

    57

          if (typeid(*current_var_type_symbol) == typeid(sint_type_name_c)) return true;

    58

          if (typeid(*current_var_type_symbol) == typeid(usint_type_name_c)) return true;

    59

          if (typeid(*current_var_type_symbol) == typeid(string_type_name_c)) return true;

    60

          if (typeid(*current_var_type_symbol) == typeid(byte_type_name_c)) return true;

    61

          break;

    62

        case 'W': // Word, 16 bits

    63

          if (typeid(*current_var_type_symbol) == typeid(int_type_name_c)) return true;

    64

          if (typeid(*current_var_type_symbol) == typeid(uint_type_name_c)) return true;

    65

          if (typeid(*current_var_type_symbol) == typeid(word_type_name_c)) return true;

    66

          if (typeid(*current_var_type_symbol) == typeid(wstring_type_name_c)) return true;

    67

          break;

    68

        case 'D': // Double, 32 bits

    69

          if (typeid(*current_var_type_symbol) == typeid(dint_type_name_c)) return true;

    70

          if (typeid(*current_var_type_symbol) == typeid(udint_type_name_c)) return true;

    71

          if (typeid(*current_var_type_symbol) == typeid(real_type_name_c)) return true;

    72

          if (typeid(*current_var_type_symbol) == typeid(dword_type_name_c)) return true;

    73

          break;

    74

        case 'L': // Long, 64 bits

    75

          if (typeid(*current_var_type_symbol) == typeid(lint_type_name_c)) return true;

    76

          if (typeid(*current_var_type_symbol) == typeid(ulint_type_name_c)) return true;

    77

          if (typeid(*current_var_type_symbol) == typeid(lreal_type_name_c)) return true;

    78

          if (typeid(*current_var_type_symbol) == typeid(lword_type_name_c)) return true;

    79

          break;

    80

        default:

    81

          if (typeid(*current_var_type_symbol) == typeid(bool_type_name_c)) return true;

    82

      }

    83

      return false;

    84

    }

    85

    86

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

    87

/* B.1.4.1   Directly Represented Variables */

    88

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

    89

    90

    void *visit(direct_variable_c *symbol) {

    91

      if (current_var_type_symbol) {

    92

        s4o.print("__LOCATED_VAR(");

    93

        current_var_type_symbol->accept(*generate_c_base);

    94

        s4o.print(",");

    95

        /* Do not use print_token() as it will change everything into uppercase */

    96

        s4o.printlocation((symbol->value)+1);

    97

        s4o.print(",");

    98

        s4o.printlocation_comasep((symbol->value)+1);

    99

        s4o.print(")\n");

   100

      }

   101

      return NULL;

   102

    }

   103

   104

   105

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

   106

/* B.1.4.3   Declaration and initilization  */

   107

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

   108

   109

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

   110

/* variable_name -> may be NULL ! */

   111

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

   112

    void *visit(located_var_decl_c *symbol) {

   113

        current_var_type_symbol = spec_init_sperator_c::get_spec(symbol->located_var_spec_init);

   114

        if (current_var_type_symbol == NULL)

   115

          ERROR;

   116

   117

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

   118

        if (current_var_type_symbol == NULL)

   119

          ERROR;

   120

   121

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

   122

   123

        current_var_type_symbol = NULL;

   124

        return NULL;

   125

    }

   126

   127

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

   128

/* type_specification ->may be NULL ! */

   129

//SYM_REF2(global_var_decl_c, global_var_spec, type_specification)

   130

    void *visit(global_var_decl_c *symbol) {

   131

        current_var_type_symbol = spec_init_sperator_c::get_spec(symbol->type_specification);

   132

        if (current_var_type_symbol == NULL)

   133

          ERROR;

   134

   135

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

   136

        if (current_var_type_symbol == NULL)

   137

          ERROR;

   138

   139

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

   140

   141

        current_var_type_symbol = NULL;

   142

        return NULL;

   143

    }

   144

   145

/*  AT direct_variable */

   146

//SYM_REF2(location_c, direct_variable, unused)

   147

    void *visit(location_c *symbol) {

   148

      if (test_location_type(symbol->direct_variable))

   149

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

   150

      else

   151

        ERROR;

   152

      return NULL;

   153

    }

   154

   155

}; /* generate_location_list_c */