1

/*

     2

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

     3

 *

     4

 *  Copyright (C) 2009-2012  Mario de Sousa (msousa@fe.up.pt)

     5

 *  Copyright (C) 2012       Manuele Conti  (conti.ma@alice.it)

     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

#ifndef _HELPER_FUNCTIONS_HH_

    26

#define _HELPER_FUNCTIONS_HH_

    27

    28

#include "../absyntax/visitor.hh"

    29

#include <typeinfo>

    30

    31

    32

    33

    34

/* A small helper class, to transform elementary data type to string.

    35

 * this allows us to generate more relevant error messages...

    36

 */

    37

    38

class elementary_type_c: public null_visitor_c {

    39

  protected:

    40

    elementary_type_c(void)  {};

    41

    ~elementary_type_c(void) {};

    42

    43

  private:

    44

    /* singleton class! */

    45

    static elementary_type_c *singleton;

    46

    47

  public:

    48

    static const char * to_string(symbol_c *symbol);

    49

    50

    51

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

    52

    /* B 1.3.1 - Elementary Data Types */

    53

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

    54

    void *visit(time_type_name_c *symbol)        {return (void *)"TIME";        };

    55

    void *visit(bool_type_name_c *symbol)        {return (void *)"BOOL";        };

    56

    void *visit(sint_type_name_c *symbol)        {return (void *)"SINT";        };

    57

    void *visit(int_type_name_c *symbol)         {return (void *)"INT";         };

    58

    void *visit(dint_type_name_c *symbol)        {return (void *)"DINT";        };

    59

    void *visit(lint_type_name_c *symbol)        {return (void *)"LINT";        };

    60

    void *visit(usint_type_name_c *symbol)       {return (void *)"USINT";       };

    61

    void *visit(uint_type_name_c *symbol)        {return (void *)"UINT";        };

    62

    void *visit(udint_type_name_c *symbol)       {return (void *)"UDINT";       };

    63

    void *visit(ulint_type_name_c *symbol)       {return (void *)"ULINT";       };

    64

    void *visit(real_type_name_c *symbol)        {return (void *)"REAL";        };

    65

    void *visit(lreal_type_name_c *symbol)       {return (void *)"LREAL";       };

    66

    void *visit(date_type_name_c *symbol)        {return (void *)"DATE";        };

    67

    void *visit(tod_type_name_c *symbol)         {return (void *)"TOD";         };

    68

    void *visit(dt_type_name_c *symbol)          {return (void *)"DT";          };

    69

    void *visit(byte_type_name_c *symbol)        {return (void *)"BYTE";        };

    70

    void *visit(word_type_name_c *symbol)        {return (void *)"WORD";        };

    71

    void *visit(lword_type_name_c *symbol)       {return (void *)"LWORD";       };

    72

    void *visit(dword_type_name_c *symbol)       {return (void *)"DWORD";       };

    73

    void *visit(string_type_name_c *symbol)      {return (void *)"STRING";      };

    74

    void *visit(wstring_type_name_c *symbol)     {return (void *)"WSTRING";     };

    75

    76

    void *visit(safetime_type_name_c *symbol)    {return (void *)"SAFETIME";    };

    77

    void *visit(safebool_type_name_c *symbol)    {return (void *)"SAFEBOOL";    };

    78

    void *visit(safesint_type_name_c *symbol)    {return (void *)"SAFESINT";    };

    79

    void *visit(safeint_type_name_c *symbol)     {return (void *)"SAFEINT";     };

    80

    void *visit(safedint_type_name_c *symbol)    {return (void *)"SAFEDINT";    };

    81

    void *visit(safelint_type_name_c *symbol)    {return (void *)"SAFELINT";    };

    82

    void *visit(safeusint_type_name_c *symbol)   {return (void *)"SAFEUSINT";   };

    83

    void *visit(safeuint_type_name_c *symbol)    {return (void *)"SAFEUINT";    };

    84

    void *visit(safeudint_type_name_c *symbol)   {return (void *)"SAFEUDINT";   };

    85

    void *visit(safeulint_type_name_c *symbol)   {return (void *)"SAFEULINT";   };

    86

    void *visit(safereal_type_name_c *symbol)    {return (void *)"SAFEREAL";    };

    87

    void *visit(safelreal_type_name_c *symbol)   {return (void *)"SAFELREAL";   };

    88

    void *visit(safedate_type_name_c *symbol)    {return (void *)"SAFEDATE";    };

    89

    void *visit(safetod_type_name_c *symbol)     {return (void *)"SAFETOD";     };

    90

    void *visit(safedt_type_name_c *symbol)      {return (void *)"SAFEDT";      };

    91

    void *visit(safebyte_type_name_c *symbol)    {return (void *)"SAFEBYTE";    };

    92

    void *visit(safeword_type_name_c *symbol)    {return (void *)"SAFEWORD";    };

    93

    void *visit(safelword_type_name_c *symbol)   {return (void *)"SAFELWORD";   };

    94

    void *visit(safedword_type_name_c *symbol)   {return (void *)"SAFEDWORD";   };

    95

    void *visit(safestring_type_name_c *symbol)  {return (void *)"SAFESTRING";  };

    96

    void *visit(safewstring_type_name_c *symbol) {return (void *)"SAFEWSTRING"; };

    97

};

    98

extern elementary_type_c *elementary_type;

    99

   100

   101

   102

   103

   104

#define is_type(type_name_symbol, type_name_class)  ((type_name_symbol == NULL) ? false : (typeid(*type_name_symbol) == typeid(type_name_class)))

   105

#define sizeoftype(symbol) get_sizeof_datatype_c::getsize(symbol)

   106

   107

/* Widening Primitive Conversion */

   108

struct widen_entry {

   109

	symbol_c *left;

   110

	symbol_c *right;

   111

	symbol_c *result;

   112

};

   113

/*

   114

 * 2.5.1.5.6 Functions of time data types

   115

 * Table 30 - page 64

   116

 */

   117

extern const struct widen_entry widen_ADD_table[];

   118

extern const struct widen_entry widen_SUB_table[];

   119

extern const struct widen_entry widen_MUL_table[];

   120

extern const struct widen_entry widen_DIV_table[];

   121

   122

/* Search for a datatype inside a candidate_datatypes list.

   123

 * Returns: position of datatype in the list, or -1 if not found.

   124

 */

   125

int search_in_datatype_list(symbol_c *datatype, std::vector <symbol_c *> candidate_datatypes);

   126

   127

/* A helper function... */

   128

bool is_ANY_ELEMENTARY_type         (symbol_c *type_symbol);

   129

bool is_ANY_SAFEELEMENTARY_type     (symbol_c *type_symbol);

   130

bool is_ANY_ELEMENTARY_compatible   (symbol_c *type_symbol);

   131

   132

bool is_ANY_MAGNITUDE_type          (symbol_c *type_symbol);

   133

bool is_ANY_SAFEMAGNITUDE_type      (symbol_c *type_symbol);

   134

bool is_ANY_MAGNITUDE_compatible    (symbol_c *type_symbol);

   135

   140

bool is_ANY_DATE_type               (symbol_c *type_symbol);

   141

bool is_ANY_SAFEDATE_type           (symbol_c *type_symbol);

   142

bool is_ANY_DATE_compatible         (symbol_c *type_symbol);

   143

   144

bool is_ANY_STRING_type             (symbol_c *type_symbol);

   145

bool is_ANY_SAFESTRING_type         (symbol_c *type_symbol);

   146

bool is_ANY_STRING_compatible       (symbol_c *type_symbol);

   147

   148

bool is_ANY_INT_type                (symbol_c *type_symbol);

   149

bool is_ANY_SAFEINT_type            (symbol_c *type_symbol);

   150

bool is_ANY_INT_compatible          (symbol_c *type_symbol);

   151

   156

bool is_ANY_REAL_type               (symbol_c *type_symbol);

   157

bool is_ANY_SAFEREAL_type           (symbol_c *type_symbol);

   158

bool is_ANY_REAL_compatible         (symbol_c *type_symbol);

   159

   160

bool is_ANY_NUM_type                (symbol_c *type_symbol);

   161

bool is_ANY_SAFENUM_type            (symbol_c *type_symbol);

   162

bool is_ANY_NUM_compatible          (symbol_c *type_symbol);

   163

   168

bool is_ANY_BIT_type                (symbol_c *type_symbol);

   169

bool is_ANY_SAFEBIT_type            (symbol_c *type_symbol);

   170

bool is_ANY_BIT_compatible          (symbol_c *type_symbol);

   171

   172

bool is_BOOL_type                   (symbol_c *type_symbol);

   173

bool is_SAFEBOOL_type               (symbol_c *type_symbol);

   174

bool is_ANY_BOOL_compatible         (symbol_c *type_symbol);

   175

   176

#if 0

   177

bool is_nonneg_literal_integer_type (symbol_c *type_symbol);

   178

bool is_literal_integer_type        (symbol_c *type_symbol);

   179

bool is_literal_real_type           (symbol_c *type_symbol);

   180

bool is_literal_bool_type           (symbol_c *type_symbol);

   181

   182

/* Determine the common data type between two data types.

   183

 * If no common data type found, return NULL.

   184

 *

   185

 * If data types are identical, return the first (any would do...).

   186

 * If any of the data types is a literal, we confirm that

   187

 *   the literal uses less bits than the fixed size data type.

   188

 *   e.g. BYTE and 1024 returns NULL

   189

 *        BYTE and 255  returns BYTE

   190

 *

   191

 * If two literals, then return the literal that requires more bits...

   192

 */

   193

symbol_c *common_type(symbol_c *first_type, symbol_c *second_type);

   194

bool is_valid_assignment(symbol_c *var_type, symbol_c *value_type);

   195

bool is_compatible_type(symbol_c *first_type, symbol_c *second_type);

   196

#endif

   197

   198

bool is_type_equal(symbol_c *first_type, symbol_c *second_type);

   199

   200

// typedef bool (*helper_function_t) (symbol_c *type_symbol);  /* a pointer to a function! */

   201

   202

   203

   204

#endif /* _HELPER_FUNCTIONS_HH_ */