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.

    27

 *

    28

 * This is used to create symbol tables such as a list of

    29

 * variables currently in scope, etc...

    30

 * Note that the list of previously defined funstions uses the

    31

 * dsymtable_c instead, as it requires the table to store duplicate values.

    32

 */

    33

    34

    35

#include <iostream>

    36

#include "symtable.hh"

    37

#include "../main.hh" // required for ERROR() and ERROR_MSG() macros.

    38

    39

    40

    41

    42

    43

    44

template<typename value_type>

    45

symtable_c<value_type>::symtable_c(void) {inner_scope = NULL;}

    46

    47

    48

 /* clear all entries... */

    49

template<typename value_type>

    50

void symtable_c<value_type>::reset(void) {

    51

  _base.clear();

    52

}

    53

    54

 /* create new inner scope */

    55

template<typename value_type>

    56

void symtable_c<value_type>::push(void) {

    57

  if (inner_scope != NULL) {

    58

    inner_scope->push();

    59

  } else {

    60

    inner_scope = new symtable_c();

    61

  }

    62

}

    63

    64

  /* clear most inner scope */

    65

  /* returns 1 if this is the inner most scope	*/

    66

  /*         0 otherwise			*/

    67

template<typename value_type>

    68

int symtable_c<value_type>::pop(void) {

    69

  if (inner_scope != NULL) {

    70

    if (inner_scope->pop() == 1) {

    71

      delete inner_scope;

    72

      inner_scope = NULL;

    73

    }

    74

    return 0;

    75

  } else {

    76

    _base.clear();

    77

    return 1;

    78

  }

    79

}

    80

    81

template<typename value_type>

    82

void symtable_c<value_type>::set(const symbol_c *symbol, value_t new_value) {

    83

  if (inner_scope != NULL) {

    84

    inner_scope->set(symbol, new_value);

    85

    return;

    86

  }

    87

    88

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

    89

  if (name == NULL)

    90

    ERROR;

    91

  set(name->value, new_value);

    92

}

    93

    94

    95

template<typename value_type>

    96

void symtable_c<value_type>::set(const char *identifier_str, value_t new_value) {

    97

  if (inner_scope != NULL) {

    98

    inner_scope->set(identifier_str, new_value);

    99

    return;

   100

  }

   101

   102

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

   103

  iterator i = _base.find(identifier_str);

   104

  if (i == _base.end())

   105

    /* identifier not already in map! */

   106

    ERROR;

   107

   108

  _base[identifier_str] = new_value;

   109

}

   110

   111

template<typename value_type>

   112

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

   113

  if (inner_scope != NULL) {

   114

    inner_scope->insert(identifier_str, new_value);

   115

    return;

   116

  }

   117

   118

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

   119

  iterator i = _base.find(identifier_str);

   120

  if ((i != _base.end()) && (i->second != new_value)) {ERROR;}  /* error inserting new identifier: identifier already in map associated to a different value */

   121

  if ((i != _base.end()) && (i->second == new_value)) {return;} /* identifier already in map associated with the same value */

   122

   123

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

   124

  std::pair<iterator, bool> res = _base.insert(new_element);

   125

  if (!res.second) {ERROR;} /* unknown error inserting new identifier */

   126

}

   127

   128

template<typename value_type>

   129

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

   130

/*

   131

// not required...

   132

  if (inner_scope != NULL) {

   133

    inner_scope->insert(symbol, new_value);

   134

    return;

   135

  }

   136

*/

   137

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

   138

  if (name == NULL)

   139

    ERROR;

   140

  insert(name->value, new_value);

   141

}

   142

   143

   144

template<typename value_type>

   145

typename symtable_c<value_type>::iterator symtable_c<value_type>::end(void) {return _base.end();}

   146

   147

/* returns end() if not found! */

   148

template<typename value_type>

   149

typename symtable_c<value_type>::iterator symtable_c<value_type>::find(const char *identifier_str) {

   150

  if (inner_scope != NULL) {

   151

    iterator i = inner_scope->find(identifier_str);

   152

    if (i != inner_scope->end())  // NOTE: must use the end() value of the inner scope!

   153

      /* found in the lower level */

   154

      return i;

   155

  }

   156

   157

  /* if no lower level, or not found in lower level... */

   158

  return _base.find(identifier_str);

   159

}

   160

   161

   162

template<typename value_type>

   163

typename symtable_c<value_type>::iterator symtable_c<value_type>::find(const symbol_c *symbol) {

   164

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

   165

  if (name == NULL)

   166

    ERROR;

   167

  return find(name->value);

   168

}

   169

   170

   171

   172

/* debuging function... */

   173

template<typename value_type>

   174

void symtable_c<value_type>::print(void) {

   175

  for(iterator i = _base.begin();

   176

      i != _base.end();

   177

      i++)

   178

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

   179

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

   180

   181

  if (inner_scope != NULL) {

   182

    inner_scope->print();

   183

  }

   184

}

   185

   186

   187

   188

   189

   190

   191

   192