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

 * A generic symbol table.

    26

 *

    27

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

    28

 * variables currently in scope, a list of previously defined

    29

 * functions, etc...

    30

 */

    31

    32

    33

    34

#ifndef _SYMTABLE_HH

    35

#define _SYMTABLE_HH

    36

    37

#include "../absyntax/absyntax.hh"

    38

    39

#include <map>

    40

#include <string>

    41

    42

    43

    44

    45

template<typename value_type> class symtable_c {

    46

  /* Case insensitive string compare copied from

    47

   * "The C++ Programming Language" - 3rd Edition

    48

   * by Bjarne Stroustrup, ISBN 0201889544.

    49

   */

    50

  class nocase_c {

    51

    public:

    52

      bool operator() (const std::string& x, const std::string& y) const {

    53

        std::string::const_iterator ix = x.begin();

    54

        std::string::const_iterator iy = y.begin();

    55

    56

        for(; (ix != x.end()) && (iy != y.end()) && (toupper(*ix) == toupper(*iy)); ++ix, ++iy);

    57

        if (ix == x.end()) return (iy != y.end());

    58

        if (iy == y.end()) return false;

    59

        return (toupper(*ix) < toupper(*iy));

    60

      };

    61

  };

    62

    63

  public:

    64

    typedef value_type value_t;

    65

    66

  private:

    67

    /* Comparison between identifiers must ignore case, therefore the use of nocase_c */

    68

    typedef std::map<std::string, value_t, nocase_c> base_t;

    69

    base_t _base;

    70

    71

  public:

    72

  typedef typename base_t::iterator iterator;

    73

  typedef typename base_t::const_iterator const_iterator;

    74

  typedef typename base_t::reverse_iterator reverse_iterator;

    75

  typedef typename base_t::const_reverse_iterator const_reverse_iterator;

    76

    77

  private:

    78

      /* pointer to symbol table of the next inner scope */

    79

    symtable_c *inner_scope;

    80

    81

  public:

    82

    symtable_c(void);

    83

    84

    void clear(void); /* clear all entries... */

    85

    86

    void push(void); /* create new inner scope */

    87

    int  pop(void);  /* clear most inner scope */

    88

    89

    void set(const char *identifier_str, value_t value);    // Will change value associated to string if already in map. Will create new entry if string not in map.

    90

    void set(const symbol_c *symbol, value_t value);        // Will change value associated to string if already in map. Will create new entry if string not in map.

    91

    void insert(const char *identifier_str, value_t value); // insert a new (string,value) pair. Give an error if string already in map associated to different value!

    92

    void insert(const symbol_c *symbol, value_t value);     // insert a new (string,value) pair. Give an error if string already in map associated to different value!

    93

    94

    value_t& operator[](const       char *identifier_str);

    95

    value_t& operator[](const std::string identifier_str);

    96

 // value_t& operator[](const   symbol_c *identifier    ); // not yet implemented

    97

    98

    /* Since symtable_c does not allow duplicates in each level, count() will return

    99

     *  - 0 : if not found in any level

   100

     *  - n : number of level containing that entry (max is current number of levels!)

   101

     */

   102

    int count(const       char *identifier_str);

   103

    int count(const std::string identifier_str);

   104

 // int count(const   symbol_c *identifier    ); // not yet implemented

   105

   106

    /* Search for an entry. Will return end() if not found */

   107

    iterator               begin(void);

   108

    iterator               end  (void);

   109

    iterator               find (const char       *identifier_str);

   110

    iterator               find (const std::string identifier_str);

   111

    iterator               find (const symbol_c   *symbol        );

   112

   113

   114

  /* iterators ... */

   115

  /* NOTE: These member functions are incorrect, as the returned iterator will not iterate through the inner_scopes!! */

   116

  /*       We simply comment it all out, as they are not currently needed!                                            */

   117

  #if 0

   118

    iterator               find (const char *identifier_str)

   119

    iterator               begin()                          

   120

    const_iterator         begin()  const                   

   121

    iterator               end()                            

   122

    const_iterator         end()    const                   

   123

    reverse_iterator       rbegin()                         

   124

    const_reverse_iterator rbegin() const                   

   125

    reverse_iterator       rend()                           

   126

    const_reverse_iterator rend()   const                   

   127

  #endif

   128

    /* debuging function... */

   129

    void print(void);

   130

};

   131

   132

   133

   134

/* Templates must include the source into the code! */

   135

#include "symtable.cc"

   136

   137

#endif /*  _SYMTABLE_HH */