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

 * A generic symbol table that allows duplicate values.

    27

 *

    28

 * This is used to create a symbol table of previously defined

    29

 * functions. Duplicate are allowed since the standard permits function\

    30

 * overloading in the standard library.

    31

 */

    32

    33

    34

#include <iostream>

    35

#include "symtable.hh"

    36

    37

    38

    39

/* A macro for printing out internal parser errors... */

    40

#define ERROR error_exit(__FILE__,__LINE__)

    41

/* function defined in main.cc */

    42

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

    43

    44

    45

    46

    47

 /* clear all entries... */

    48

template<typename value_type, value_type null_value>

    49

void dsymtable_c<value_type, null_value>::reset(void) {

    50

  _base.clear();

    51

}

    52

    53

    54

template<typename value_type, value_type null_value>

    55

void dsymtable_c<value_type, null_value>::insert(const char *identifier_str, value_t new_value) {

    56

  // std::cout << "store_identifier(" << identifier_str << "): \n";

    57

  std::pair<const char *, value_t> new_element(identifier_str, new_value);

    58

  /* iterator res = */ _base.insert(new_element);

    59

}

    60

    61

    62

template<typename value_type, value_type null_value>

    63

void dsymtable_c<value_type, null_value>::insert(const symbol_c *symbol, value_t new_value) {

    64

  const token_c *name = dynamic_cast<const token_c *>(symbol);

    65

  if (name == NULL)

    66

    ERROR;

    67

  insert(name->value, new_value);

    68

}

    69

    70

    71

#if 0

    72

template<typename value_type, value_type null_value>

    73

void dsymtable_c<value_type, null_value>::insert_noduplicate(const char *identifier_str, value_t new_value) {

    74

  if (find_value(identifier_str) != null_value)

    75

    /* already present in the set! */

    76

    ERROR;

    77

    78

  // std::cout << "store_identifier(" << identifier_str << "): \n";

    79

  std::pair<const char *, value_t> new_element(identifier_str, new_value);

    80

  /* iterator res = */ _base.insert(new_element);

    81

}

    82

    83

    84

template<typename value_type, value_type null_value>

    85

void dsymtable_c<value_type, null_value>::insert_noduplicate(const symbol_c *symbol, value_t new_value) {

    86

  const token_c *name = dynamic_cast<const token_c *>(symbol);

    87

  if (name == NULL)

    88

    ERROR;

    89

  insert_noduplicate(name->value, new_value);

    90

}

    91

#endif

    92

    93

    94

    95

/* Determine how many entries are associated to key identifier_str */ 

    96

/* returns:

    97

 *         0: if no entry is found

    98

 *         1: if 1 entry is found

    99

 *         2: if more than 1 entry is found 

   100

 */

   101

template<typename value_type, value_type null_value>

   102

int dsymtable_c<value_type, null_value>::multiplicity(const char *identifier_str) {

   103

  iterator lower = _base.lower_bound(identifier_str);

   104

  if (lower == _base.end()) return 0;

   105

   106

  iterator upper = _base.upper_bound(identifier_str);

   107

  iterator second = lower;

   108

  second++;

   109

   110

  if (second == upper) return 1;

   111

   112

  return 2;

   113

}

   114

   115

   116

/* returns null_value if not found! */

   117

template<typename value_type, value_type null_value>

   118

value_type dsymtable_c<value_type, null_value>::find_value(const char *identifier_str) {

   119

  iterator i = _base.find(identifier_str);

   120

   121

  if (i == _base.end())

   122

    return null_value;

   123

  else

   124

    return i->second;

   125

}

   126

   127

   128

template<typename value_type, value_type null_value>

   129

const char * dsymtable_c<value_type, null_value>::symbol_to_string(const symbol_c *symbol) {

   130

  const token_c *name = dynamic_cast<const token_c *>(symbol);

   131

  if (name == NULL)

   132

    ERROR;

   133

  return name->value;

   134

}

   135

   136

   137

/* debuging function... */

   138

template<typename value_type, value_type null_value>

   139

void dsymtable_c<value_type, null_value>::print(void) {

   140

  for(iterator i = _base.begin();

   141

      i != _base.end();

   142

      i++)

   143

    std::cout << i->second << ":" << i->first << "\n";

   144

  std::cout << "=====================\n";

   145

}

   146

   147

   148

   149

   150

   151

   152

   153

   154