source: icXML/icXML-devel/src/icxmlc/XMLConfig.hpp @ 2807

Last change on this file since 2807 was 2807, checked in by cameron, 7 years ago

Fixes default attribute+namespace resolution; hashing

File size: 11.6 KB
Line 
1/*
2 *  Copyright © 2012 International Characters.
3 *  This software is licensed to the public under the Open Software License 3.0.
4 *  icXML is a trademark of International Characters.
5 */
6
7/*
8 * @author Nigel Medforth, nigelm -at- interational-characters.com
9 * @version $Id: XMLConfig.hpp 243 2013-01-12 00:31:44Z nigelm $
10 *
11 */
12
13/*********************************** FUNCTIONALITY CONFIGURATIONS *************************************/
14
15#include <xercesc/util/XercesDefs.hpp>
16
17#ifndef SHOW_CALLSTACK_FOR_DEPRECATED_FEATURES
18#define SHOW_CALLSTACK_FOR_DEPRECATED_FEATURES
19#endif
20
21#ifndef PRINT_DEBUG_MESSAGE
22//#define PRINT_DEBUG_MESSAGE
23#endif
24
25#ifndef PRINT_DEBUG_IGNORE_TRANSITION_STREAM_MESSAGES
26#define PRINT_DEBUG_IGNORE_TRANSITION_STREAM_MESSAGES
27#endif
28
29#ifndef PRINT_DEBUG_IGNORE_GRAMMAR_MESSAGES
30#define PRINT_DEBUG_IGNORE_GRAMMAR_MESSAGES
31#endif
32
33#ifndef PRINT_DEBUG_IGNORE_NAMESPACE_MESSAGES
34#define PRINT_DEBUG_IGNORE_NAMESPACE_MESSAGES
35#endif
36
37#ifndef PRINT_DEBUG_IGNORE_SYMBOL_STREAM_MESSAGES
38#define PRINT_DEBUG_IGNORE_SYMBOL_STREAM_MESSAGES
39#endif
40
41#ifndef PRINT_DEBUG_IGNORE_WELL_FORMEDNESS_MESSAGES
42#define PRINT_DEBUG_IGNORE_WELL_FORMEDNESS_MESSAGES
43#endif
44
45#ifndef DISABLE_PARSER_LINE_COLUMN_CALCULATION
46#define DISABLE_PARSER_LINE_COLUMN_CALCULATION
47#endif
48
49#ifndef USE_SIMPLE_HASH_TABLE_LOOKUP
50#define USE_SIMPLE_HASH_TABLE_LOOKUP
51#endif
52
53#ifndef TEST_NAMESPACE_RESOLVER
54#define TEST_NAMESPACE_RESOLVER
55#endif
56
57#ifndef TEST_CUCKOO_HASH_TABLE
58#define TEST_CUCKOO_HASH_TABLE
59#endif
60
61#ifndef TEST_PER_SYMBOL_ELEM_DECL_LISTS
62#define TEST_PER_SYMBOL_ELEM_DECL_LISTS
63#endif
64
65#if !defined(STORE_CHILDREN_INFORMATION_IN_PARSER)
66#define STORE_CHILDREN_INFORMATION_IN_PARSER
67#endif
68
69#if !defined(PERFORM_ELEMENT_STACK_MATCHING_IN_PARSER)
70#define PERFORM_ELEMENT_STACK_MATCHING_IN_PARSER
71#endif
72
73#if !defined(TEST_ENTITY_EXPANSION)
74#define TEST_ENTITY_EXPANSION
75#endif
76
77#if !defined(INTERGRATE_SYMBOL_RESOLUTION_INTO_CHARACTER_SET_ADAPTER)
78#define INTERGRATE_SYMBOL_RESOLUTION_INTO_CHARACTER_SET_ADAPTER
79#endif
80
81#if !defined(CALCULATE_COPY_BACK_POSITION)
82 //#define CALCULATE_COPY_BACK_POSITION
83#endif
84
85#if !defined(USE_UTF16_BIG_ENDIAN)
86// #define USE_UTF16_BIG_ENDIAN
87#endif
88
89#if !defined(ICXML_ENABLE_VERSION1_1)
90#define ICXML_ENABLE_VERSION1_1  // to safely turn this on, any symbol ending with a NEL must be 'truncated' to remove the erroneous bytes.
91#endif
92
93#if !defined(IGNORE_DEFAULT_ATTRIBUTES)
94// #define IGNORE_DEFAULT_ATTRIBUTES
95#endif
96
97#if !defined(TEST_WELLFORMEDNESS_CHECKER)
98#define TEST_WELLFORMEDNESS_CHECKER
99#endif
100
101#ifndef BIND_ALL_XMLNS_SYMBOLS_TO_THE_XMLNS_NAMESPACE
102#define BIND_ALL_XMLNS_SYMBOLS_TO_THE_XMLNS_NAMESPACE
103#endif
104
105
106/* does nothing so far; there is an advantage in replacing the internal attr list functionality
107   with a more refined one--but this will require modifying the /internal/VecAttrListImpl and
108   /internal/VecAttributesImpl classes to support the new type */
109//#define REPLACE_INTERNAL_SCANNER_ATTRIBUTE_LIST
110
111#ifndef XML_CONFIG_HPP_GUARD
112#define XML_CONFIG_HPP_GUARD
113
114        #include <simd-lib/bitblock.hpp>
115
116    typedef ScanWord scanword_t;
117
118    #ifdef __ARCH_64
119    #undef __ARCH_64
120    #endif
121
122    #if defined (_MSC_VER) && defined(_M_X64)
123    #define __ARCH_64
124    #elif defined (__GNUC__) && defined(__x86_64__)
125    #define __ARCH_64
126    #endif
127
128    #ifdef __ARCH_X86
129    #undef __ARCH_X86
130    #endif
131
132    #if defined(_MSC_VER) && defined(_M_X86)
133        #define __ARCH_X86
134    #elif defined (__GNUC__) && (defined(__i386__) || defined(__arm__))
135        #define __ARCH_X86
136    #endif
137
138        #include <icxmlc/clog2.h>
139        #include <cstddef>
140
141        enum
142        {
143                LOG_2_BLOCK_SIZE = CONST_LOG_2(BLOCK_SIZE)
144        };
145
146        /************************************ BUFFER SIZE CONFIGURATIONS **************************************/
147
148        #define BUFFER_BLOCKS ((16 * 1024) / BLOCK_SIZE)
149
150        #define INITIAL_CONTENT_BUFFER_SIZE (2 * BUFFER_BLOCKS * BLOCK_SIZE)
151
152    #define INITIAL_SYMBOL_TABLE_CAPACITY 64    // NOTE MUST BE A POWER OF 2; TODO: investigate whether prime numbers are better given the cost of the mod
153
154        #define INITIAL_SYMBOL_TABLE_STRING_POOL_SIZE (1024)
155
156        #define INITIAL_MAX_SCOPE 16
157
158        #define EXPECTED_LEAF_NODE_COUNT 32
159
160        #define INITIAL_ATTRIBUTE_LIST_SIZE 16
161
162        #define INITIAL_NAMESPACE_RESOLVER_STRING_POOL_SIZE 2048
163
164        #define GET_CONTEXT_ID_FOR_EACH_ELEMENT
165
166        #if INITIAL_CONTENT_BUFFER_SIZE > (64 * 1024)
167        #define USE_HEAP_ALLOCATION_FOR_XML_PARSER
168        #endif
169
170        /* PREFETCH */
171        #ifdef __GNUC__
172                #define PREFETCH(x) __builtin_prefetch((void*)(x));
173        #elif defined _MSC_VER
174                #define PREFETCH(x) _mm_prefetch((char*)(x), _MM_HINT_NTA);
175        #else
176                #define PREFETCH(x)
177        #endif
178
179        /* UNREACHABLE */
180        #ifdef _DEBUG
181                #define UNREACHABLE assert(!"UNREACHABLE CODE EXECUTED!");
182        #elif defined(__GNUC__)
183                // built-in unreachable is only valid from gcc 4.5 and above
184                #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
185                #define UNREACHABLE __builtin_unreachable(); // requires -Wunreachable-code?
186                #else
187                #define UNREACHABLE abort();
188                #endif
189        #elif defined _MSC_VER
190                #define UNREACHABLE __assume(0);
191        #else
192                #define UNREACHABLE
193        #endif
194
195        /* ASSUME */
196        #ifdef __GNUC__
197                // built-in unreachable is only valid from gcc 4.5 and above
198                #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
199                #define ASSUME(cond) // do { if (!(cond)) { UNREACHABLE } } while (0);
200                #else
201                #define ASSUME(cond)
202                #endif
203        #elif defined _MSC_VER
204                #define ASSUME(cond) __assume(cond);
205        #else
206                #define ASSUME(cond)
207        #endif
208
209        /* IS_COMPILE_TIME_CONSTANT */
210        #define IS_COMPILE_TIME_CONSTANT(x) x//__builtin_constant_p(x)
211
212        /* DEPRECATED_FEATURE_IN_ICXML */
213        #ifdef SHOW_CALLSTACK_FOR_DEPRECATED_FEATURES
214                #include <icxmlc/backtrace.h>
215                #define DEPRECATED_FEATURE_IN_ICXML assert(deprecatedFeatureUsed()); throw;
216        #else
217                #define DEPRECATED_FEATURE_IN_ICXML throw;/* TODO: create xerces-compatible exception to throw */
218        #endif
219
220        #ifdef USE_SIMPLE_HASH_TABLE_LOOKUP
221                typedef uint32_t gid_t;
222        #else
223                #include <icxmlc/symbol_table/src/gid.hpp>
224                typedef gid_type gid_t;
225        #endif
226
227        #ifdef PRINT_DEBUG_MESSAGE
228
229                #include <icxercesc/util/XMLString.hpp>
230                #include <iostream>
231                #include <iomanip>
232
233                #define DEBUG_MESSAGE(MSG) \
234                        try \
235                        { \
236                                XERCES_STD_QUALIFIER clog << MSG << XERCES_STD_QUALIFIER endl; \
237                        } \
238                        catch (...) \
239                        { \
240                                XERCES_STD_QUALIFIER clog << "!! DEBUG MESSAGE ERROR: " << __FILE__ << "." << __LINE__ << " !!" << XERCES_STD_QUALIFIER endl; \
241                                exit(-2); \
242                        }
243
244                XERCES_CPP_NAMESPACE_BEGIN
245
246        template<typename Char>
247        static inline std::ostream & __printKey(std::ostream & out, const Char * key, const size_t length)
248        {
249            Char keyBuf[1024] = {0};
250            const size_t keyLen = length < 1024 ? length : 1023;
251            memcpy(keyBuf, key, keyLen);
252            out << keyBuf;
253            return out;
254        }
255
256        inline void __normalize_whitespace(std::ostream & out, char * string)
257                {
258            char * ptr = string;
259            out << '"';
260                        while (*ptr)
261                        {
262                                if (unlikely(*ptr < 0x20))
263                                {
264                                        unsigned int val = *ptr;
265                                        *ptr = 0;
266
267                                        out << string << '\\' << std::hex << val << std::dec;
268
269                                        string = ptr + 1;
270                                }
271                                ptr++;
272                        }
273            out << string << '"';
274                }
275
276                inline static std::ostream & operator << (std::ostream & out, const XMLCh * const string)
277                {
278                        if (string)
279                        {
280                                try
281                                {
282
283                    char buf[1024];
284                    char * output;
285                                        XMLSize_t len = XMLString::stringLen(string);
286
287                                        if (len < 1024)
288                                        {
289                                                XMLString::transcode(string, &buf[0], 1024);
290                                                __normalize_whitespace(out, &buf[0]);
291                                        }
292                                        else
293                                        {
294                                                output = XMLString::transcode(string);
295                                                __normalize_whitespace(out, output);
296                                                XMLString::release(&output);
297                                        }
298
299//                    const XMLCh * ptr = string;
300
301//                    char buf[257] = {0};
302
303//                    const char hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7'
304//                                         , '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
305
306//                    size_t i = 0;
307//                    bool done = 0;
308//                    while (!done)
309//                    {
310//                        for (int j = 0; j < 8; j++)
311//                        {
312//                            XMLCh ch = *ptr++;
313
314//                            done |= (*ptr == 0);
315
316//                            XMLCh d = ch & 15;
317//                            XMLCh c = (ch >> 4) & 15;
318//                            XMLCh b = (ch >> 8) & 15;
319//                            XMLCh a = (ch >> 12) & 15;
320
321//                            buf[i + 0] = hex[a];
322//                            buf[i + 1] = hex[b];
323//                            buf[i + 2] = hex[c];
324//                            buf[i + 3] = hex[d];
325
326//                            i += 4;
327
328//                            if (i == 256)
329//                            {
330//                                out << (const char*)&buf[0];
331//                                i = 0;
332//                            }
333//                        }
334//                    }
335//                    buf[i] = 0;
336//                    out << (const char*)&buf[0];
337                                }
338                                catch (std::exception & e)
339                                {
340                                        out << '|' << e.what() << '|';
341                                }
342                                catch (...)
343                                {
344                                        /* do nothing */
345                                }
346                        }
347                        return out;
348                }
349
350                inline static std::ostream & operator << (std::ostream & out, const BytePack & block)
351                {
352                        char output[sizeof(BytePack) * 3] = {0};
353
354                        const char hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7'
355                                                                 , '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
356
357                        ubitblock value;
358                        value._128 = block;
359
360                        for(unsigned int i = 0; i < sizeof(BytePack); i++)
361                        {
362                                const char c = value._8[i];
363                                const size_t offset = (sizeof(BytePack) - 1 - i) * 3;
364                                output[offset] = hex[(c & 0xF0) >> 4];
365                                output[offset + 1] = hex[c & 0x0F];
366                                output[offset + 2] = ' ';
367                        }
368
369                        out << output;
370
371                        return out;
372                }
373
374                XERCES_CPP_NAMESPACE_END
375
376        #else
377                #define DEBUG_MESSAGE(MSG)
378        #endif
379
380        #if !defined(PRINT_DEBUG_IGNORE_TRANSITION_STREAM_MESSAGES)
381                #define DEBUG_TRANSITION_MESSAGE(MSG) DEBUG_MESSAGE(MSG)
382        #else
383                #define DEBUG_TRANSITION_MESSAGE(MSG)
384        #endif
385
386        #if !defined(PRINT_DEBUG_IGNORE_GRAMMAR_MESSAGES)
387                #define DEBUG_GRAMMAR_MESSAGE(MSG) DEBUG_MESSAGE(MSG)
388        #else
389                #define DEBUG_GRAMMAR_MESSAGE(MSG)
390        #endif
391
392        #if !defined(PRINT_DEBUG_IGNORE_NAMESPACE_MESSAGES)
393                #define DEBUG_NAMESPACE_MESSAGE(MSG) DEBUG_MESSAGE(MSG)
394        #else
395                #define DEBUG_NAMESPACE_MESSAGE(MSG)
396        #endif
397
398    #if !defined(PRINT_DEBUG_IGNORE_SYMBOL_STREAM_MESSAGES)
399        #define DEBUG_SYMBOL_MESSAGE(MSG) DEBUG_MESSAGE(MSG)
400    #else
401        #define DEBUG_SYMBOL_MESSAGE(MSG)
402    #endif
403
404    #if !defined(PRINT_DEBUG_IGNORE_WELL_FORMEDNESS_MESSAGES)
405        #define DEBUG_WELL_FORMEDNESS_MESSAGE(MSG) DEBUG_MESSAGE(MSG)
406    #else
407        #define DEBUG_WELL_FORMEDNESS_MESSAGE(MSG)
408    #endif
409
410        IDISA_ALWAYS_INLINE
411        static BitBlock maskli(const uint64_t position)
412        {
413                return bitblock::sll(simd<1>::constant<1>(), convert(position));
414        }
415
416        IDISA_ALWAYS_INLINE
417        static BitBlock maskre(const uint64_t position)
418        {
419                return simd_not(maskli(position));
420        }
421
422        IDISA_ALWAYS_INLINE
423        static BitBlock maskri(const uint64_t position)
424        {
425                return bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE - 1 - position));
426        }
427
428        IDISA_ALWAYS_INLINE
429        static BitBlock maskle(const uint64_t position)
430        {
431                return simd_not(maskri(position));
432        }
433
434        IDISA_ALWAYS_INLINE
435        static void store_aligned_bypass_cache(const BitBlock reg, BitBlock * const output)
436        {
437                #ifndef IGNORE_CACHE_BYPASS
438                _mm_stream_si128(output, reg);
439                #else
440                bitblock::store_aligned(reg, output);
441                #endif
442        }
443
444        IDISA_ALWAYS_INLINE
445        static void load_fence()
446        {
447                #ifndef IGNORE_CACHE_BYPASS
448                _mm_lfence();
449                #endif
450        }
451
452        IDISA_ALWAYS_INLINE
453        static void store_fence()
454        {
455                #ifndef IGNORE_CACHE_BYPASS
456                _mm_mfence();
457                #endif
458        }
459
460#endif
Note: See TracBrowser for help on using the repository browser.