source: trunk/src/symtab.c @ 139

Last change on this file since 139 was 139, checked in by lindanl, 11 years ago

Storing name length in Name Table.

File size: 8.6 KB
Line 
1#include "symtab.h"
2
3inline char * copy_name (char * s, int lgth){           
4        char * d = new char[lgth+1];
5        memcpy(d, s,lgth); 
6        d[lgth] = '\0'; 
7        return d;
8}
9
10inline bool bit_test(unsigned char * bit_Map, int codepoint) {
11        return (bit_Map[codepoint/8] >> (7 - codepoint % 8)) & 1;
12}
13
14
15bool is_XML10_NameStrt_codepoint(int codepoint) {
16        switch (codepoint >> 12) {
17                case 0: return bit_test(NameStrt_XML10_0000_11FF, codepoint);
18                case 1: if (codepoint <= 0x11FF)
19                                return bit_test(NameStrt_XML10_0000_11FF, codepoint);
20                        else if (codepoint < 0x1E00) return false;
21                        else return bit_test(NameStrt_XML10_1E00_1FFF, codepoint & 0x1FF);
22                case 2: if (codepoint > 0x2182) return false;
23                        else return bit_test(NameStrt_XML10_2000_21FF, codepoint & 0x1FF);
24                case 3: if (codepoint > 0x312C) return false;
25                        else return bit_test(NameStrt_XML10_3000_31FF, codepoint & 0x1FF);
26                case 4: return codepoint >= 0x4E00;
27                case 5: case 6: case 7: case 8: return true;
28                case 9: return codepoint <= 0x9FA5;
29                case 0xA: return codepoint >= 0xAC00;
30                case 0xB: case 0xC: return true;
31                case 0xD: return codepoint <= 0xD7A3;
32                default: return false;
33        }
34}
35
36bool is_XML10_NameChar_codepoint(int codepoint) {
37        switch (codepoint >> 12) {
38                case 0: return bit_test(NameChar_XML10_0000_11FF, codepoint);
39                case 1: if (codepoint <= 0x11FF)
40                                return bit_test(NameChar_XML10_0000_11FF, codepoint);
41                        else if (codepoint < 0x1E00) return false;
42                        else return bit_test(NameStrt_XML10_1E00_1FFF, codepoint & 0x1FF);
43                case 2: if (codepoint > 0x2182) return false;
44                        else return bit_test(NameChar_XML10_2000_21FF, codepoint & 0x1FF);
45                case 3: if (codepoint > 0x312C) return false;
46                        else return bit_test(NameChar_XML10_3000_31FF, codepoint & 0x1FF);
47                case 4: return codepoint >= 0x4E00;
48                case 5: case 6: case 7: case 8: return true;
49                case 9: return codepoint <= 0x9FA5;
50                case 0xA:       return codepoint >= 0xAC00;
51                case 0xB: case 0xC: return true;
52                case 0xD: return codepoint <= 0xD7A3;
53                default: return false;
54        }
55}
56
57bool is_XML11_NameStrt_codepoint(int codepoint) {
58        if (likely(codepoint) <= 0x03FF) return bit_test(NameStrt_XML11_0000_03FF, codepoint);
59        else switch (codepoint >> 12) {
60                case 0: case 1: return true;
61                case 2: if (codepoint >= 0x2070) 
62                                if (codepoint <= 0x218F) return true;
63                                else return (codepoint >= 0x2C00) & (codepoint <= 0x2FEF);
64                        else return (codepoint >= 0x200C) & (codepoint <= 0x200D);
65                case 3: return codepoint >= 0x3001;
66                case 4: case 5: case 6: case 7: case 8: case 9: case 0xA: case 0xB: case 0xC: return true;
67                case 0xD: return codepoint <= 0xD7FF;
68                case 0xE: return false;
69                case 0xF: if (codepoint <= 0xFDCF) return codepoint >= 0xF900;
70                          else return (codepoint >= 0xFDF0) & (codepoint <= 0xFFFD);
71                default: return codepoint <= 0xEFFFF;
72        }
73}
74
75bool is_XML11_NameChar_codepoint(int codepoint) {
76        if (likely(codepoint) <= 0x03FF) return bit_test(NameChar_XML11_0000_03FF, codepoint);
77        else switch (codepoint >> 12) {
78                case 0: case 1: return true;
79                case 2: if (codepoint >= 0x2070) 
80                                if (codepoint <= 0x218F) return true;
81                                else return (codepoint >= 0x2C00) & (codepoint <= 0x2FEF);
82                        else if (codepoint <= 0x200D) return codepoint >= 0x200C;
83                        else return (codepoint == 0x203F) | (codepoint == 0x2040);
84                case 3: return codepoint >= 0x3001;
85                case 4: case 5: case 6: case 7: case 8: case 9: case 0xA: case 0xB: case 0xC: return true;
86                case 0xD: return codepoint <= 0xD7FF;
87                case 0xE: return false;
88                case 0xF: if (codepoint <= 0xFDCF) return codepoint >= 0xF900;
89                          else return (codepoint >= 0xFDF0) & (codepoint <= 0xFFFD);
90                default: return codepoint <= 0xEFFFF;
91        }
92}
93
94inline int XML_10_UTF8_NameStrt_bytes (unsigned char bytes[]) {
95        if (bytes[0] <= 0x7F) {
96                if (bit_test(NameStrt_XML10_0000_11FF, (int) bytes[0])) return 1;
97                else return 0;
98        }
99        else if (bytes[0] <= 0xDF) {
100                int codepoint = ((bytes[0] & 0x3F) << 6) | (bytes[1] & 0x3F);
101                if (bit_test(NameStrt_XML10_0000_11FF, codepoint)) return 2;
102                else return 0;
103        }
104        else if (bytes[0] <= 0xEF) {
105                int codepoint = ((bytes[0] & 0x0F) << 12)| ((bytes[1] & 0x3F) << 6) | (bytes[2] & 0x3F);
106                return is_XML10_NameStrt_codepoint(codepoint) ? 3 : 0;
107        }
108        else return 0;
109}
110
111inline int XML_10_UTF8_NameChar_bytes (unsigned char bytes[]) {
112        if (bytes[0] <= 0x7F) {
113                if (bit_test(NameChar_XML10_0000_11FF, (int) bytes[0])) return 1;
114                else return 0;
115        }
116        else if (bytes[0] <= 0xDF) {
117                int codepoint = ((bytes[0] & 0x3F) << 6) | (bytes[1] & 0x3F);
118                if (bit_test(NameChar_XML10_0000_11FF, codepoint)) return 2;
119                else return 0;
120        }
121        else if (bytes[0] <= 0xEF) {
122                int codepoint = ((bytes[0] & 0x0F) << 12)| ((bytes[1] & 0x3F) << 6) | (bytes[2] & 0x3F);
123                return is_XML10_NameStrt_codepoint(codepoint) ? 3 : 0;
124        }
125        else return 0;
126}
127
128inline int XML_11_UTF8_NameStrt_bytes (unsigned char bytes[]) {
129        if (bytes[0] <= 0x7F) {
130                if (bit_test(NameStrt_XML11_0000_03FF, (int) bytes[0])) return 1;
131                else return 0;
132        }
133        else if (bytes[0] <= 0xDF) {
134                int codepoint = ((bytes[0] & 0x3F) << 6) | (bytes[1] & 0x3F);
135                return is_XML11_NameStrt_codepoint(codepoint) ? 2 : 0;
136        }
137        else if (bytes[0] <= 0xEF) {
138                int codepoint = ((bytes[0] & 0x0F) << 12)| ((bytes[1] & 0x3F) << 6) | (bytes[2] & 0x3F);
139                return is_XML11_NameStrt_codepoint(codepoint) ? 3 : 0;
140        }
141        else {
142                int codepoint = ((bytes[0] & 0x0F) << 18)| ((bytes[1] & 0x3F) << 12) | 
143                                ((bytes[2] & 0x3F) << 6) | (bytes[3] & 0x3F);
144                return is_XML11_NameStrt_codepoint(codepoint) ? 4 : 0;
145        }
146}
147
148inline int XML_11_UTF8_NameChar_bytes (unsigned char bytes[]) {
149        if (bytes[0] <= 0x7F) {
150                if (bit_test(NameChar_XML11_0000_03FF, (int) bytes[0])) return 1;
151                else return 0;
152        }
153        else if (bytes[0] <= 0xDF) {
154                int codepoint = ((bytes[0] & 0x3F) << 6) | (bytes[1] & 0x3F);
155                return is_XML11_NameChar_codepoint(codepoint) ? 2 : 0;
156        }
157        else if (bytes[0] <= 0xEF) {
158                int codepoint = ((bytes[0] & 0x0F) << 12)| ((bytes[1] & 0x3F) << 6) | (bytes[2] & 0x3F);
159                return is_XML11_NameChar_codepoint(codepoint) ? 3 : 0;
160        }
161        else {
162                int codepoint = ((bytes[0] & 0x0F) << 18)| ((bytes[1] & 0x3F) << 12) | 
163                                ((bytes[2] & 0x3F) << 6) | (bytes[3] & 0x3F);
164                return is_XML11_NameChar_codepoint(codepoint) ? 4 : 0;
165        }
166}
167
168bool is_XML10_UTF8_Name(char protoname[], int lgth) {
169        int valid_bytes = XML_10_UTF8_NameStrt_bytes((unsigned char *) protoname);
170        int pos = valid_bytes;
171        while ((valid_bytes > 0) & (pos < lgth)) {
172                valid_bytes = XML_10_UTF8_NameChar_bytes((unsigned char *) &protoname[pos]);
173                pos += valid_bytes;
174        }
175        /* Success requires that every byte sequence processed be valid
176           and that the total lgth processed be exactly that provided on
177           input. */
178        return (valid_bytes > 0) & (pos == lgth);
179}
180
181bool is_XML11_UTF8_Name(char protoname[], int lgth) {
182        int valid_bytes = XML_11_UTF8_NameStrt_bytes((unsigned char *) protoname);
183        int pos = valid_bytes;
184        while ((valid_bytes > 0) & (pos < lgth)) {
185                valid_bytes = XML_11_UTF8_NameChar_bytes((unsigned char *) &protoname[pos]);
186                pos += valid_bytes;
187        }
188        /* Success requires that every byte sequence processed be valid
189           and that the total lgth processed be exactly that provided on
190           input. */
191        return (valid_bytes > 0) & (pos == lgth);
192}
193
194int Symbol_Table::UTF8_Lookup_or_Insert_XML10_Name(char * name, int lgth) {
195        char * s = copy_name(name,lgth);
196        int nameID = UTF8NameMap[s];
197        if(nameID == 0){
198                if (!is_XML10_UTF8_Name(name,lgth)) {
199                        ShowSyntaxError(NT_Name);
200                        exit(-1);
201                }
202                UTF8NameMap[s]=++(globalNameCount);
203                nameID = globalNameCount;
204                Name_Data name_data;
205                name_data.name_string = s;
206                name_data.lgth = lgth;
207                UTF8NameTable.push_back(name_data);
208//              UTF8NameTable.push_back(s);
209        }
210        return nameID;
211}
212
213int Symbol_Table::UTF8_Lookup_or_Insert_XML11_Name(char * name, int lgth) {
214        char * s = copy_name(name,lgth);
215        int nameID = UTF8NameMap[s];
216        if(nameID == 0){
217                if (!is_XML11_UTF8_Name(name,lgth))  {
218                        ShowSyntaxError(NT_Name);
219                        exit(-1);
220                }
221                UTF8NameMap[s]=++(globalNameCount);
222                nameID = globalNameCount;
223                Name_Data name_data;
224                name_data.name_string = s;
225                name_data.lgth = lgth;
226                UTF8NameTable.push_back(name_data);
227//              UTF8NameTable.push_back(s);
228        }
229        return nameID;
230}
231
232//char * Symbol_Table::Get_UTF8_name(int nameID) {
233//      return  UTF8NameTable[nameID];
234//}
235
236char * Symbol_Table::Get_UTF8_name(int nameID) {
237        return  UTF8NameTable[nameID].name_string;
238}
239
240int Symbol_Table::Get_UTF8_lgth(int nameID) {
241        return  UTF8NameTable[nameID].lgth;
242}
243
244Symbol_Table::Symbol_Table(){
245        globalNameCount = 0;
246        Name_Data name_data;
247        name_data.name_string = NULL;
248        name_data.lgth = 0;
249        UTF8NameTable.push_back(name_data);
250//      UTF8NameTable.push_back(NULL);
251        for (int i = 0; i < 5; i++) {
252                UTF8NameMap[predefined[i]] = ++(globalNameCount);
253                Name_Data name_data;
254                name_data.name_string = predefined[i];
255                name_data.lgth = strlen(predefined[i]);
256                UTF8NameTable.push_back(name_data);
257//              UTF8NameTable.push_back(predefined[i]);
258        }
259}
260
261
Note: See TracBrowser for help on using the repository browser.