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

    34

  public:

    35

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

    36

      generate_c_base = new generate_c_base_c(s4o_ptr);

    37

      current_var_type_symbol = NULL;

    38

    }

    39

    ~generate_location_list_c(void) {

    40

      delete generate_c_base;

    41

    }

    42

    43

    bool test_location_type(symbol_c *direct_variable) {

    44

    45

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

    46

    47

      if (location == NULL)

    48

        /* invalid identifiers... */

    49

        return false;

    50

    51

      switch (location->value[2]) {

    52

        case 'X': // bit

    53

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

    54

          break;

    55

        case 'B': // Byte, 8 bits

    56

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

    57

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

    58

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

    59

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

    60

          break;

    61

        case 'W': // Word, 16 bits

    62

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

    63

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

    64

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

    65

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

    66

          break;

    67

        case 'D': // Double, 32 bits

    68

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

    69

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

    70

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

    71

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

    72

          break;

    73

        case 'L': // Long, 64 bits

    74

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

    75

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

    76

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

    77

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

    78

          break;

    79

        default:

    80

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

    81

      }

    82

      return false;

    83

    }

    84

    85

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

    86

/* B.1.4.1   Directly Represented Variables */

    87

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

    88

    89

    void *visit(direct_variable_c *symbol) {

    90

      if (current_var_type_symbol) {

    91

        s4o.print("__LOCATED_VAR(");

    92

        current_var_type_symbol->accept(*generate_c_base);

    93

        s4o.print(",");

    94

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

    95

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

    96

        s4o.print(",");

    97

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

    98

        s4o.print(")\n");

    99

      }

   100

      return NULL;

   101

    }

   102

   103

   104

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

   105

/* B.1.4.3   Declaration and initilization  */

   106

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

   107

   108

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

   109

/* variable_name -> may be NULL ! */

   110

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

   111

    void *visit(located_var_decl_c *symbol) {

   112

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

   113

        if (current_var_type_symbol == NULL)

   114

          ERROR;

   115

   116

        current_var_type_symbol = search_base_type_c::get_basetype_decl(current_var_type_symbol);

   117

        if (current_var_type_symbol == NULL)

   118

          ERROR;

   119

   120

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

   121

   122

        current_var_type_symbol = NULL;

   123

        return NULL;

   124

    }

   125

   126

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

   127

/* type_specification ->may be NULL ! */

   128

//SYM_REF2(global_var_decl_c, global_var_spec, type_specification)

   129

    void *visit(global_var_decl_c *symbol) {

   130

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

   131

        if (current_var_type_symbol == NULL)

   132

          ERROR;

   133

   134

        current_var_type_symbol = search_base_type_c::get_basetype_decl(current_var_type_symbol);

   135

        if (current_var_type_symbol == NULL)

   136

          ERROR;

   137

   138

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

   139

   140

        current_var_type_symbol = NULL;

   141

        return NULL;

   142

    }

   143

   144

/*  AT direct_variable */

   145

//SYM_REF2(location_c, direct_variable, unused)

   146

    void *visit(location_c *symbol) {

   147

      if (test_location_type(symbol->direct_variable))

   148

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

   149

      else

   150

        ERROR;

   151

      return NULL;

   152

    }

   153

   154

}; /* generate_location_list_c */