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>::clear(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

int symtable_c<value_type>::count(const       char *identifier_str) {return _base.count(identifier_str)+((inner_scope == NULL)?0:inner_scope->count(identifier_str));}

   146

template<typename value_type>

   147

int symtable_c<value_type>::count(const std::string identifier_str) {return _base.count(identifier_str)+((inner_scope == NULL)?0:inner_scope->count(identifier_str));}

   148

   149

   150

// in the operator[] we delegate to find(), since that method will also search in the inner scopes!

   151

template<typename value_type>

   152

typename symtable_c<value_type>::value_t& symtable_c<value_type>::operator[] (const       char *identifier_str) {iterator i = find(identifier_str); return (i!=end())?i->second:_base[identifier_str];}

   153

template<typename value_type>

   154

typename symtable_c<value_type>::value_t& symtable_c<value_type>::operator[] (const std::string identifier_str) {iterator i = find(identifier_str); return (i!=end())?i->second:_base[identifier_str];}

   155

   156

   157

template<typename value_type>

   158

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

   159

   160

template<typename value_type>

   161

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

   162

   163

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

   164

template<typename value_type>

   165

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

   166

  iterator i;

   167

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

   168

      return i;  // found in the lower level

   169

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

   170

  return _base.find(identifier_str);

   171

}

   172

   173

   174

template<typename value_type>

   175

typename symtable_c<value_type>::iterator symtable_c<value_type>::find(const std::string identifier_str) {

   176

  iterator i;

   177

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

   178

      return i;  // found in the lower level

   179

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

   180

  return _base.find(identifier_str);

   181

}

   182

   183

   184

template<typename value_type>

   185

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

   186

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

   187

  if (name == NULL)

   188

    ERROR;

   189

  return find(name->value);

   190

}

   191

   192

   193

   194

/* debuging function... */

   195

template<typename value_type>

   196

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

   197

  for(iterator i = _base.begin();

   198

      i != _base.end();

   199

      i++)

   200

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

   201

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

   202

   203

  if (inner_scope != NULL) {

   204

    inner_scope->print();

   205

  }

   206

}

   207

   208

   209

   210

   211

   212

   213

   214