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

/*

    27

 * A generic symbol table that allows duplicate values.

    28

 *

    29

 * This is used to create a symbol table of previously defined

    30

 * functions. Duplicate are allowed since the standard permits function\

    31

 * overloading in the standard library.

    32

 */

    33

    34

    35

    36

#ifndef _DSYMTABLE_HH

    37

#define _DSYMTABLE_HH

    38

    39

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

    40

    41

#include <map>

    42

#include <string>

    43

    44

    45

    46

    47

template<typename value_type> class dsymtable_c {

    48

  /* Case insensitive string compare copied from

    49

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

    50

   * by Bjarne Stroustrup, ISBN 0201889544.

    51

   */

    52

  class nocase_c {

    53

    public:

    54

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

    55

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

    56

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

    57

    58

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

    59

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

    60

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

    61

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

    62

      };

    63

  };

    64

    65

  public:

    66

    typedef value_type value_t;

    67

    68

  private:

    69

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

    70

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

    71

    base_t _base;

    72

    73

  public:

    74

  typedef typename base_t::iterator iterator;

    75

  typedef typename base_t::const_iterator const_iterator;

    76

  typedef typename base_t::reverse_iterator reverse_iterator;

    77

  typedef typename base_t::const_reverse_iterator const_reverse_iterator;

    78

    79

  private:

    80

    const char *symbol_to_string(const symbol_c *symbol);

    81

    82

  public:

    83

    dsymtable_c(void) {};

    84

    85

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

    86

    87

    void insert(const char *identifier_str, value_t value);

    88

    void insert(const symbol_c *symbol, value_t value);

    89

    90

    /* Determine how many entries are associated to key identifier_str */ 

    91

    /* returns: 0 if no entry is found, 1 if 1 entry is found, ..., n if n entries are found */

    92

    int count(const char *identifier_str)    {return _base.count(identifier_str);}

    93

    int count(const symbol_c *symbol)        {return count(symbol_to_string(symbol));}

    94

    95

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

    96

    iterator find(const char *identifier_str)        {return _base.find(identifier_str);}

    97

    iterator find(const symbol_c *symbol)            {return find(symbol_to_string(symbol));}

    98

    99

    /* Search for the first entry associated with (i.e. with key ==) identifier_str. Will return end() if not found (NOTE: end() != end_value()) */

   100

    iterator lower_bound(const char *identifier_str) {return ((count(identifier_str) == 0)? _base.end() : _base.lower_bound(identifier_str));}

   101

    iterator lower_bound(const symbol_c *symbol)     {return lower_bound(symbol_to_string(symbol));}

   102

   103

    /* Search for the first entry with key greater than identifier_str. Will return end() if not found */

   104

    iterator upper_bound(const char *identifier_str) {return ((count(identifier_str) == 0)? _base.end() : _base.upper_bound(identifier_str));}

   105

    iterator upper_bound(const symbol_c *symbol)     {return upper_bound(symbol_to_string(symbol));}

   106

   107

    /* get the value to which an iterator is pointing to... */

   108

    value_t get_value(const iterator i) {return i->second;}

   109

   110

  /* iterators pointing to beg/end of map... */

   111

    iterator begin() 			{return _base.begin();}

   112

    const_iterator begin() const	{return _base.begin();}

   113

    iterator end()			{return _base.end();}

   114

    const_iterator end() const 		{return _base.end();}

   115

    reverse_iterator rbegin()		{return _base.rbegin();}

   116

    const_reverse_iterator rbegin() const {return _base.rbegin();}

   117

    reverse_iterator rend() 		{return _base.rend();}

   118

    const_reverse_iterator rend() const	{return _base.rend();}

   119

   120

    /* debuging function... */

   121

    void print(void);

   122

};

   123

   124

   125

   126

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

   127

#include "dsymtable.cc"

   128

   129

#endif /*  _DSYMTABLE_HH */