source: trunk/src/symtab.c @ 1509

Last change on this file since 1509 was 825, checked in by cameron, 9 years ago

Move bitmap base NameStart/NameChar? tests into namechars.h

File size: 8.1 KB
Line 
1#include "symtab.h"
2
3bool is_XML10_UTF8_Name(char protoname[], int lgth) {
4        int valid_bytes = XML_10_UTF8_NameStrt_bytes((unsigned char *) protoname);
5        int pos = valid_bytes;
6        while ((valid_bytes > 0) & (pos < lgth)) {
7                valid_bytes = XML_10_UTF8_NameChar_bytes((unsigned char *) &protoname[pos]);
8                pos += valid_bytes;
9
10        }
11        /* Success requires that every byte sequence processed be valid
12           and that the total lgth processed be exactly that provided on
13           input. */
14
15        return (valid_bytes > 0) & (pos == lgth);
16}
17
18bool is_XML11_UTF8_Name(char protoname[], int lgth) {
19        int valid_bytes = XML_11_UTF8_NameStrt_bytes((unsigned char *) protoname);
20        int pos = valid_bytes;
21        while ((valid_bytes > 0) & (pos < lgth)) {
22                valid_bytes = XML_11_UTF8_NameChar_bytes((unsigned char *) &protoname[pos]);
23                pos += valid_bytes;
24        }
25        /* Success requires that every byte sequence processed be valid
26           and that the total lgth processed be exactly that provided on
27           input. */
28        return (valid_bytes > 0) & (pos == lgth);
29}
30
31bool is_XML10_UTF8_Nmtoken(char prototoken[], int lgth) {
32        int valid_bytes = XML_10_UTF8_NameChar_bytes((unsigned char *) prototoken);
33        int pos = valid_bytes;
34        while ((valid_bytes > 0) & (pos < lgth)) {
35                valid_bytes = XML_10_UTF8_NameChar_bytes((unsigned char *) &prototoken[pos]);
36                pos += valid_bytes;
37
38        }
39        /* Success requires that every byte sequence processed be valid
40           and that the total lgth processed be exactly that provided on
41           input. */
42
43        return (valid_bytes > 0) & (pos == lgth);
44}
45
46bool is_XML11_UTF8_Nmtoken(char prototoken[], int lgth) {
47        int valid_bytes = XML_11_UTF8_NameChar_bytes((unsigned char *) prototoken);
48        int pos = valid_bytes;
49        while ((valid_bytes > 0) & (pos < lgth)) {
50                valid_bytes = XML_11_UTF8_NameChar_bytes((unsigned char *) &prototoken[pos]);
51                pos += valid_bytes;
52        }
53        /* Success requires that every byte sequence processed be valid
54           and that the total lgth processed be exactly that provided on
55           input. */
56        return (valid_bytes > 0) & (pos == lgth);
57}
58
59int Symbol_Table::Insert_Name(const char * name, int lgth) {
60//      char * s = copy_name(name,lgth);
61        char * s = pool.Insert(name,lgth);
62        UTF8NameMap[s]=++(globalNameCount);
63        Name_Data name_data;
64        name_data.name_string = s;
65        name_data.lgth = lgth;
66        UTF8NameTable.push_back(name_data);
67        return globalNameCount;
68}
69
70
71inline bool Verify_ASCII(char * name_ptr, int name_lgth) {
72        /* To verify that a name is ASCII, ensure that the high bit
73           of each byte is 0.  A SIMD compare can verify this for
74           up to sizeof(BytePack) bytes.  For less than 16 bytes,
75           first shift out bytes beyond the name length.  For more
76           than 16 bytes, form the logical "or" of the successive byte
77           packs together so that a high 1 bit in any byte is preserved
78           for the final SIMD test. */
79        BytePack b = sisd_load_unaligned((BytePack *) name_ptr);
80        if (name_lgth <= sizeof(BytePack)) {
81                /* Clear bytes beyond the length of the name. */
82                b = sisd_sfl(b, sisd_from_int(8 * (sizeof(BytePack) - name_lgth)));
83        }
84        else {
85                int offset = name_lgth % sizeof(BytePack);
86                for (int i = offset; i < name_lgth; i += sizeof(BytePack)) {
87                        b = simd_or(sisd_load_unaligned((BytePack *) &name_ptr[i]),b);
88                }
89        }
90#ifdef TEMPLATED_SIMD_LIB
91        return !simd_any_sign_bit<8>(b);
92#endif
93#ifndef TEMPLATED_SIMD_LIB
94        return !simd_any_sign_bit_8(b);
95#endif
96}
97
98
99/* ASCII_LookupOrInsert determines the nameID for any ASCII name
100from the global name table, inserting the name and allocating
101a nameID if necessary.  If the name is non-ASCII, 0 is returned. */
102
103inline int Symbol_Table::ASCII_Lookup_or_Insert_Name(char * name_ptr, int name_lgth) {
104
105        if (Verify_ASCII(name_ptr, name_lgth)) {
106                return UTF8_Lookup_or_Insert_Name(name_ptr, name_lgth);
107        }
108        return 0;
109}
110
111
112
113int Symbol_Table::UTF8_Lookup_or_Insert_Name(char * name, int lgth) {
114
115        char delim = name[lgth];
116        name[lgth] = '\0';
117        int nameID = UTF8NameMap[name];
118        name[lgth] = delim;
119
120        if(nameID == 0){
121        #if (not defined(OMISSION)) or (OMISSION != NAME_VALIDATION)
122#ifdef EDITION5
123                if (!is_XML11_UTF8_Name(name,lgth))  {
124                        ShowSyntaxError(NT_Name);
125                        exit(-1);
126                }
127#endif
128#ifndef EDITION5
129                if (!is_XML10_UTF8_Name(name,lgth))  {
130                        if (version == XML_1_1) {
131                                if (!is_XML11_UTF8_Name(name,lgth))  {
132                                        ShowSyntaxError(NT_Name);
133                                        exit(-1);
134                                }
135                        }
136                        else {
137                                ShowSyntaxError(NT_Name);
138                                exit(-1);
139                        }
140                }
141#endif
142        #endif
143//              char * s = copy_name(name,lgth);
144                char * s = pool.Insert(name,lgth);
145                UTF8NameMap[s]=++(globalNameCount);
146                nameID = globalNameCount;
147                Name_Data name_data;
148                name_data.name_string = s;
149                name_data.lgth = lgth;
150                UTF8NameTable.push_back(name_data);
151//              UTF8NameTable.push_back(s);
152        }
153        return nameID;
154}
155
156//char * Symbol_Table::Get_UTF8_name(int nameID) {
157//      return  UTF8NameTable[nameID];
158//}
159
160char * Symbol_Table::Get_UTF8_name(int nameID) {
161        return  UTF8NameTable[nameID].name_string;
162}
163
164int Symbol_Table::Get_UTF8_lgth(int nameID) {
165        return  UTF8NameTable[nameID].lgth;
166}
167
168inline int Symbol_Table::ASCII_Lookup_or_Insert_Nmtoken(char * nmtoken_ptr, int name_lgth) {
169
170        if (Verify_ASCII(nmtoken_ptr, name_lgth)) {
171                return UTF8_Lookup_or_Insert_Nmtoken(nmtoken_ptr, name_lgth);
172        }
173        return 0;
174}
175
176
177int Symbol_Table::UTF8_Lookup_or_Insert_Nmtoken(char * nmtoken, int lgth) {
178
179        char delim = nmtoken[lgth];
180        nmtoken[lgth] = '\0';
181        int nmtokenID = UTF8NmtokenMap[nmtoken];
182        nmtoken[lgth] = delim;
183
184        if(nmtokenID == 0){
185        #if (not defined(OMISSION)) or (OMISSION != NAME_VALIDATION)
186#ifdef EDITION5
187                if (!is_XML11_UTF8_Nmtoken(nmtoken,lgth))  {
188                        ShowSyntaxError(NT_Nmtoken);
189                        exit(-1);
190                }
191#endif
192#ifndef EDITION5
193                if (!is_XML10_UTF8_Nmtoken(nmtoken,lgth))  {
194                        if (version == XML_1_1) {
195                                if (!is_XML11_UTF8_Nmtoken(nmtoken,lgth))  {
196                                        ShowSyntaxError(NT_Nmtoken);
197                                        exit(-1);
198                                }
199                        }
200                        else {
201                                ShowSyntaxError(NT_Nmtoken);
202                                exit(-1);
203                        }
204                }
205#endif
206        #endif
207//              char * s = copy_name(name,lgth);
208                char * s = pool.Insert(nmtoken,lgth);
209                UTF8NmtokenMap[s]=++(globalNmtokenCount);
210                nmtokenID = globalNmtokenCount;
211                Name_Data nmtoken_data;
212                nmtoken_data.name_string = s;
213                nmtoken_data.lgth = lgth;
214                UTF8NmtokenTable.push_back(nmtoken_data);
215//              UTF8NameTable.push_back(s);
216        }
217        return nmtokenID;
218}
219
220
221
222
223char * Symbol_Table::Get_UTF8_nmtoken(int nmtokenID) {
224        return  UTF8NmtokenTable[nmtokenID].name_string;
225}
226
227int Symbol_Table::Get_UTF8_nmtoken_lgth(int nmtokenID) {
228        return  UTF8NmtokenTable[nmtokenID].lgth;
229}
230
231char * Symbol_Table::ReserveSymbolSpace(int u8_lgth) {
232        reserved = new char[u8_lgth+1];
233        reserved_lgth = u8_lgth;
234        return reserved;
235}
236
237int Symbol_Table::LookupOrInsertReserved(){
238        int nameID = UTF8NameMap[reserved];
239        if(nameID == 0){
240        #if (not defined(OMISSION)) or (OMISSION != NAME_VALIDATION)
241                if (!is_XML10_UTF8_Name(reserved,reserved_lgth))  {
242                        ShowSyntaxError(NT_Name);
243                        exit(-1);
244                }
245        #endif
246                UTF8NameMap[reserved]=++(globalNameCount);
247                nameID = globalNameCount;
248                Name_Data name_data;
249                name_data.name_string = reserved;
250                name_data.lgth = reserved_lgth;
251                UTF8NameTable.push_back(name_data);
252//              UTF8NameTable.push_back(s);
253        }
254        else {
255                delete [] reserved;
256        }
257        return nameID;
258}
259
260int Symbol_Table::LookupOrInsertReserved_nmtoken(){
261        int nmtokenID = UTF8NmtokenMap[reserved];
262        if(nmtokenID == 0){
263        #if (not defined(OMISSION)) or (OMISSION != NAME_VALIDATION)
264                if (!is_XML10_UTF8_Nmtoken(reserved,reserved_lgth))  {
265                        ShowSyntaxError(NT_Nmtoken);
266                        exit(-1);
267                }
268        #endif
269                UTF8NmtokenMap[reserved]=++(globalNmtokenCount);
270                nmtokenID = globalNmtokenCount;
271                Name_Data nmtoken_data;
272                nmtoken_data.name_string = reserved;
273                nmtoken_data.lgth = reserved_lgth;
274                UTF8NmtokenTable.push_back(nmtoken_data);
275        }
276        else {
277                delete [] reserved;
278        }
279        return nmtokenID;
280}
281
282Symbol_Table::Symbol_Table(){
283        globalNameCount = 0;
284        Name_Data name_data;
285        name_data.name_string = NULL;
286        name_data.lgth = 0;
287        UTF8NameTable.push_back(name_data);
288//      UTF8NameTable.push_back(NULL);
289/*      for (int i = 0; i < 5; i++) {
290                UTF8NameMap[predefined[i]] = ++(globalNameCount);
291                Name_Data name_data;
292                name_data.name_string = predefined[i];
293                name_data.lgth = strlen(predefined[i]);
294                UTF8NameTable.push_back(name_data);
295                printf("predefined name: %s, global name count: %d\n",predefined[i],globalNameCount);
296//              UTF8NameTable.push_back(predefined[i]);
297        }*/
298}
299
300
301
302
Note: See TracBrowser for help on using the repository browser.