39 |
39 |
40 |
40 |
41 |
41 |
42 |
42 |
43 |
43 |
44 template<typename value_type, value_type null_value> |
44 template<typename value_type> |
45 symtable_c<value_type, null_value>::symtable_c(void) {inner_scope = NULL;} |
45 symtable_c<value_type>::symtable_c(void) {inner_scope = NULL;} |
46 |
46 |
47 |
47 |
48 /* clear all entries... */ |
48 /* clear all entries... */ |
49 template<typename value_type, value_type null_value> |
49 template<typename value_type> |
50 void symtable_c<value_type, null_value>::reset(void) { |
50 void symtable_c<value_type>::reset(void) { |
51 _base.clear(); |
51 _base.clear(); |
52 } |
52 } |
53 |
53 |
54 /* create new inner scope */ |
54 /* create new inner scope */ |
55 template<typename value_type, value_type null_value> |
55 template<typename value_type> |
56 void symtable_c<value_type, null_value>::push(void) { |
56 void symtable_c<value_type>::push(void) { |
57 if (inner_scope != NULL) { |
57 if (inner_scope != NULL) { |
58 inner_scope->push(); |
58 inner_scope->push(); |
59 } else { |
59 } else { |
60 inner_scope = new symtable_c(); |
60 inner_scope = new symtable_c(); |
61 } |
61 } |
62 } |
62 } |
63 |
63 |
64 /* clear most inner scope */ |
64 /* clear most inner scope */ |
65 /* returns 1 if this is the inner most scope */ |
65 /* returns 1 if this is the inner most scope */ |
66 /* 0 otherwise */ |
66 /* 0 otherwise */ |
67 template<typename value_type, value_type null_value> |
67 template<typename value_type> |
68 int symtable_c<value_type, null_value>::pop(void) { |
68 int symtable_c<value_type>::pop(void) { |
69 if (inner_scope != NULL) { |
69 if (inner_scope != NULL) { |
70 if (inner_scope->pop() == 1) { |
70 if (inner_scope->pop() == 1) { |
71 delete inner_scope; |
71 delete inner_scope; |
72 inner_scope = NULL; |
72 inner_scope = NULL; |
73 } |
73 } |
76 _base.clear(); |
76 _base.clear(); |
77 return 1; |
77 return 1; |
78 } |
78 } |
79 } |
79 } |
80 |
80 |
81 template<typename value_type, value_type null_value> |
81 template<typename value_type> |
82 void symtable_c<value_type, null_value>::set(const symbol_c *symbol, value_t new_value) { |
82 void symtable_c<value_type>::set(const symbol_c *symbol, value_t new_value) { |
83 if (inner_scope != NULL) { |
83 if (inner_scope != NULL) { |
84 inner_scope->set(symbol, new_value); |
84 inner_scope->set(symbol, new_value); |
85 return; |
85 return; |
86 } |
86 } |
87 |
87 |
90 ERROR; |
90 ERROR; |
91 set(name->value, new_value); |
91 set(name->value, new_value); |
92 } |
92 } |
93 |
93 |
94 |
94 |
95 template<typename value_type, value_type null_value> |
95 template<typename value_type> |
96 void symtable_c<value_type, null_value>::set(const char *identifier_str, value_t new_value) { |
96 void symtable_c<value_type>::set(const char *identifier_str, value_t new_value) { |
97 if (inner_scope != NULL) { |
97 if (inner_scope != NULL) { |
98 inner_scope->set(identifier_str, new_value); |
98 inner_scope->set(identifier_str, new_value); |
99 return; |
99 return; |
100 } |
100 } |
101 |
101 |
106 ERROR; |
106 ERROR; |
107 |
107 |
108 _base[identifier_str] = new_value; |
108 _base[identifier_str] = new_value; |
109 } |
109 } |
110 |
110 |
111 template<typename value_type, value_type null_value> |
111 template<typename value_type> |
112 void symtable_c<value_type, null_value>::insert(const char *identifier_str, value_t new_value) { |
112 void symtable_c<value_type>::insert(const char *identifier_str, value_t new_value) { |
113 if (inner_scope != NULL) { |
113 if (inner_scope != NULL) { |
114 inner_scope->insert(identifier_str, new_value); |
114 inner_scope->insert(identifier_str, new_value); |
115 return; |
115 return; |
116 } |
116 } |
117 |
117 |
123 std::pair<const char *, value_t> new_element(identifier_str, new_value); |
123 std::pair<const char *, value_t> new_element(identifier_str, new_value); |
124 std::pair<iterator, bool> res = _base.insert(new_element); |
124 std::pair<iterator, bool> res = _base.insert(new_element); |
125 if (!res.second) {ERROR;} /* unknown error inserting new identifier */ |
125 if (!res.second) {ERROR;} /* unknown error inserting new identifier */ |
126 } |
126 } |
127 |
127 |
128 template<typename value_type, value_type null_value> |
128 template<typename value_type> |
129 void symtable_c<value_type, null_value>::insert(const symbol_c *symbol, value_t new_value) { |
129 void symtable_c<value_type>::insert(const symbol_c *symbol, value_t new_value) { |
130 /* |
130 /* |
131 // not required... |
131 // not required... |
132 if (inner_scope != NULL) { |
132 if (inner_scope != NULL) { |
133 inner_scope->insert(symbol, new_value); |
133 inner_scope->insert(symbol, new_value); |
134 return; |
134 return; |
139 ERROR; |
139 ERROR; |
140 insert(name->value, new_value); |
140 insert(name->value, new_value); |
141 } |
141 } |
142 |
142 |
143 |
143 |
|
144 template<typename value_type> |
|
145 typename symtable_c<value_type>::iterator symtable_c<value_type>::end(void) {return _base.end();} |
144 |
146 |
145 /* returns null_value if not found! */ |
147 /* returns end() if not found! */ |
146 template<typename value_type, value_type null_value> |
148 template<typename value_type> |
147 value_type symtable_c<value_type, null_value>::find_value(const char *identifier_str) { |
149 typename symtable_c<value_type>::iterator symtable_c<value_type>::find(const char *identifier_str) { |
148 if (inner_scope != NULL) { |
150 if (inner_scope != NULL) { |
149 value_t token = inner_scope->find_value(identifier_str); |
151 iterator i = inner_scope->find(identifier_str); |
150 if (token != null_value) |
152 if (i != inner_scope->end()) // NOTE: must use the end() value of the inner scope! |
151 /* found in the lower level */ |
153 /* found in the lower level */ |
152 return token; |
154 return i; |
153 } |
155 } |
154 |
156 |
155 /* if no lower level, or not found in lower level... */ |
157 /* if no lower level, or not found in lower level... */ |
156 iterator i = _base.find(identifier_str); |
158 return _base.find(identifier_str); |
157 |
|
158 if (i == _base.end()) |
|
159 return null_value; |
|
160 else |
|
161 return i->second; |
|
162 } |
159 } |
163 |
160 |
164 |
161 |
165 template<typename value_type, value_type null_value> |
162 template<typename value_type> |
166 value_type symtable_c<value_type, null_value>::find_value(const symbol_c *symbol) { |
163 typename symtable_c<value_type>::iterator symtable_c<value_type>::find(const symbol_c *symbol) { |
167 const token_c *name = dynamic_cast<const token_c *>(symbol); |
164 const token_c *name = dynamic_cast<const token_c *>(symbol); |
168 if (name == NULL) |
165 if (name == NULL) |
169 ERROR; |
166 ERROR; |
170 return find_value(name->value); |
167 return find(name->value); |
171 } |
168 } |
172 |
169 |
173 |
170 |
|
171 |
174 /* debuging function... */ |
172 /* debuging function... */ |
175 template<typename value_type, value_type null_value> |
173 template<typename value_type> |
176 void symtable_c<value_type, null_value>::print(void) { |
174 void symtable_c<value_type>::print(void) { |
177 for(iterator i = _base.begin(); |
175 for(iterator i = _base.begin(); |
178 i != _base.end(); |
176 i != _base.end(); |
179 i++) |
177 i++) |
180 std::cout << i->second << ":" << i->first << "\n"; |
178 std::cout << i->second << ":" << i->first << "\n"; |
181 std::cout << "=====================\n"; |
179 std::cout << "=====================\n"; |