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

    38

    39

    40

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

    41

#define ERROR error_exit(__FILE__,__LINE__)

    42

/* function defined in main.cc */

    43

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

    44

    45

    46

    47

    48

template<typename value_type, value_type null_value>

    49

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

    50

    51

    52

 /* clear all entries... */

    53

template<typename value_type, value_type null_value>

    54

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

    55

  _base.clear();

    56

}

    57

    58

 /* create new inner scope */

    59

template<typename value_type, value_type null_value>

    60

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

    61

  if (inner_scope != NULL) {

    62

    inner_scope->push();

    63

  } else {

    64

    inner_scope = new symtable_c();

    65

  }

    66

}

    67

    68

  /* clear most inner scope */

    69

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

    70

  /*         0 otherwise			*/

    71

template<typename value_type, value_type null_value>

    72

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

    73

  if (inner_scope != NULL) {

    74

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

    75

      delete inner_scope;

    76

      inner_scope = NULL;

    77

    }

    78

    return 0;

    79

  } else {

    80

    _base.clear();

    81

    return 1;

    82

  }

    83

}

    84

    85

template<typename value_type, value_type null_value>

    86

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

    87

  if (inner_scope != NULL) {

    88

    inner_scope->set(symbol, new_value);

    89

    return;

    90

  }

    91

    92

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

    93

  if (name == NULL)

    94

    ERROR;

    95

  set(name->value, new_value);

    96

}

    97

    98

    99

template<typename value_type, value_type null_value>

   100

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

   101

  if (inner_scope != NULL) {

   102

    inner_scope->set(identifier_str, new_value);

   103

    return;

   104

  }

   105

   106

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

   107

  iterator i = _base.find(identifier_str);

   108

  if (i == _base.end())

   109

    /* identifier not already in map! */

   110

    ERROR;

   111

   112

  _base[identifier_str] = new_value;

   113

}

   114

   115

template<typename value_type, value_type null_value>

   116

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

   117

  if (inner_scope != NULL) {

   118

    inner_scope->insert(identifier_str, new_value);

   119

    return;

   120

  }

   121

   122

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

   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)

   126

    /* error inserting new identifier... */

   127

    /* identifier already in map?        */

   128

    ERROR;

   129

}

   130

   131

template<typename value_type, value_type null_value>

   132

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

   133

/*

   134

// not required...

   135

  if (inner_scope != NULL) {

   136

    inner_scope->insert(symbol, new_value);

   137

    return;

   138

  }

   139

*/

   140

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

   141

  if (name == NULL)

   142

    ERROR;

   143

  insert(name->value, new_value);

   144

}

   145

   146

   147

   148

/* returns null_value if not found! */

   149

template<typename value_type, value_type null_value>

   150

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

   151

  if (inner_scope != NULL) {

   152

    value_t token = inner_scope->find_value(identifier_str);

   153

    if (token != null_value)

   154

      /* found in the lower level */

   155

      return token;

   156

  }

   157

   158

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

   159

  iterator i = _base.find(identifier_str);

   160

   161

  if (i == _base.end())

   162

    return null_value;

   163

  else

   164

    return i->second;

   165

}

   166

   167

   168

template<typename value_type, value_type null_value>

   169

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

   170

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

   171

  if (name == NULL)

   172

    ERROR;

   173

  return find_value(name->value);

   174

}

   175

   176

   177

/* debuging function... */

   178

template<typename value_type, value_type null_value>

   179

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

   180

  for(iterator i = _base.begin();

   181

      i != _base.end();

   182

      i++)

   183

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

   184

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

   185

   186

  if (inner_scope != NULL) {

   187

    inner_scope->print();

   188

  }

   189

}

   190

   191

   192

   193

   194

   195

   196

   197

   198