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, value_type null_value>

    45

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

    46

    47

    48

 /* clear all entries... */

    49

template<typename value_type, value_type null_value>

    50

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

    51

  _base.clear();

    52

}

    53

    54

 /* create new inner scope */

    55

template<typename value_type, value_type null_value>

    56

void symtable_c<value_type, null_value>::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, value_type null_value>

    68

int symtable_c<value_type, null_value>::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, value_type null_value>

    82

void symtable_c<value_type, null_value>::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, value_type null_value>

    96

void symtable_c<value_type, null_value>::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, value_type null_value>

   112

void symtable_c<value_type, null_value>::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

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

   120

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

   121

  if (!res.second)

   122

    /* error inserting new identifier... */

   123

    /* identifier already in map?        */

   124

    ERROR;

   125

}

   126

   127

template<typename value_type, value_type null_value>

   128

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

   129

/*

   130

// not required...

   131

  if (inner_scope != NULL) {

   132

    inner_scope->insert(symbol, new_value);

   133

    return;

   134

  }

   135

*/

   136

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

   137

  if (name == NULL)

   138

    ERROR;

   139

  insert(name->value, new_value);

   140

}

   141

   142

   143

   144

/* returns null_value if not found! */

   145

template<typename value_type, value_type null_value>

   146

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

   147

  if (inner_scope != NULL) {

   148

    value_t token = inner_scope->find_value(identifier_str);

   149

    if (token != null_value)

   150

      /* found in the lower level */

   151

      return token;

   152

  }

   153

   154

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

   155

  iterator i = _base.find(identifier_str);

   156

   157

  if (i == _base.end())

   158

    return null_value;

   159

  else

   160

    return i->second;

   161

}

   162

   163

   164

template<typename value_type, value_type null_value>

   165

value_type symtable_c<value_type, null_value>::find_value(const symbol_c *symbol) {

   166

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

   167

  if (name == NULL)

   168

    ERROR;

   169

  return find_value(name->value);

   170

}

   171

   172

   173

/* debuging function... */

   174

template<typename value_type, value_type null_value>

   175

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

   176

  for(iterator i = _base.begin();

   177

      i != _base.end();

   178

      i++)

   179

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

   180

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

   181

   182

  if (inner_scope != NULL) {

   183

    inner_scope->print();

   184

  }

   185

}

   186

   187

   188

   189

   190

   191

   192

   193

   194