mirror of
https://github.com/steveicarus/iverilog.git
synced 2026-08-22 05:47:31 +02:00
Stephen Williams
052870c0e5
The vvp_island classes are added, as well as support for tranif nodes that use this concept. The result is a working implementation for tranif0 and tranif1. In the process, the symbol table functions were cleaned up and made into templates for better type safety, and the vvp_net_ptr_t was generalized so that it can be used by the branches in the island implementation. Also fix up the array handling to use the better symbol table support, and to remember to clear its own table when linking is done.
118 lines
3.8 KiB
C++
118 lines
3.8 KiB
C++
#ifndef __symbols_H
|
|
#define __symbols_H
|
|
/*
|
|
* Copyright (c) 2001-2008 Stephen Williams ([email protected])
|
|
*
|
|
* This source code is free software; you can redistribute it
|
|
* and/or modify it in source code form under the terms of the GNU
|
|
* General Public License as published by the Free Software
|
|
* Foundation; either version 2 of the License, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
|
|
*/
|
|
|
|
/*
|
|
* The symbol_table_t is intended as a means to hold and quickly index
|
|
* large symbol tables with small symbol values. That is, the value
|
|
* should fit in a 32bit unsigned integer (not even necessarily a
|
|
* pointer.)
|
|
*
|
|
* The key is an unstructured ASCII string, terminated by a
|
|
* null. Items added to the table are not removed, unless the entire
|
|
* table is deleted.
|
|
*
|
|
* The compiler uses symbol tables to help match up operands to
|
|
* referenced objects in the source. The compiler knows by the context
|
|
* that the symbol appears what kind of thing is referenced, and so
|
|
* what symbol table to look in.
|
|
*/
|
|
|
|
# include "config.h"
|
|
# include "vvp_net.h"
|
|
|
|
/*
|
|
* This is the basic type of a symbol table. It is opaque. Don't even
|
|
* try to look inside. The actual implementation is given in the
|
|
* symbols.cc source file.
|
|
*/
|
|
typedef class symbol_table_s *symbol_table_t;
|
|
|
|
typedef struct symbol_value_s {
|
|
union {
|
|
vvp_net_t*net;
|
|
void*ptr;
|
|
unsigned long num;
|
|
};
|
|
} symbol_value_t;
|
|
|
|
|
|
class symbol_table_s {
|
|
public:
|
|
explicit symbol_table_s();
|
|
virtual ~symbol_table_s();
|
|
|
|
// This method locates the value in the symbol table and sets its
|
|
// value. If the key doesn't yet exist, create it.
|
|
void sym_set_value(const char*key, symbol_value_t val);
|
|
|
|
// This method locates the value in the symbol table and returns
|
|
// it. If the value does not exist, create it, initialize it with
|
|
// zero and return the zero value.
|
|
symbol_value_t sym_get_value(const char*key);
|
|
|
|
private:
|
|
struct tree_node_*root;
|
|
struct key_strings*str_chunk;
|
|
unsigned str_used;
|
|
|
|
symbol_value_t find_value_(struct tree_node_*cur,
|
|
const char*key, symbol_value_t val,
|
|
bool force_flag);
|
|
char*key_strdup_(const char*str);
|
|
};
|
|
|
|
/*
|
|
* Create a new symbol table or release an existing one. A new symbol
|
|
* table has no keys and no values. As a symbol table is built up, it
|
|
* consumes more and more memory. When the table is no longer needed,
|
|
* the delete_symbol_table method will delete the table, including all
|
|
* the space for the keys.
|
|
*/
|
|
inline symbol_table_t new_symbol_table(void) { return new symbol_table_s; }
|
|
inline void delete_symbol_table(symbol_table_t tbl) { delete tbl; }
|
|
|
|
// These are obsolete, and here only to support older code.
|
|
inline void sym_set_value(symbol_table_t tbl, const char*key, symbol_value_t val)
|
|
{ tbl->sym_set_value(key, val); }
|
|
|
|
inline symbol_value_t sym_get_value(symbol_table_t tbl, const char*key)
|
|
{ return tbl->sym_get_value(key); }
|
|
|
|
/*
|
|
* This template is a type-safe interface to the symbol table.
|
|
*/
|
|
template <class T> class symbol_map_s : private symbol_table_s {
|
|
|
|
public:
|
|
void sym_set_value(const char*key, T*val)
|
|
{ symbol_value_t tmp;
|
|
tmp.ptr = val;
|
|
symbol_table_s::sym_set_value(key, tmp);
|
|
}
|
|
|
|
T* sym_get_value(const char*key)
|
|
{ symbol_value_t val = symbol_table_s::sym_get_value(key);
|
|
return reinterpret_cast<T*>(val.ptr);
|
|
}
|
|
};
|
|
|
|
#endif
|