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

Last change on this file was 3601, checked in by nmedfort, 5 years ago

couple fixes for namespace scope issues.

File size: 14.9 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 384 2013-10-21 22:28:13Z 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_REFERENCE_STREAM_MESSAGES
42//#define PRINT_DEBUG_IGNORE_REFERENCE_STREAM_MESSAGES
43#endif
44
45#ifndef PRINT_DEBUG_IGNORE_WELL_FORMEDNESS_MESSAGES
46//#define PRINT_DEBUG_IGNORE_WELL_FORMEDNESS_MESSAGES
47#endif
48
49#ifndef DISABLE_PARSER_LINE_COLUMN_CALCULATION
50#define DISABLE_PARSER_LINE_COLUMN_CALCULATION
51#endif
52
53#ifndef USE_SIMPLE_HASH_TABLE_LOOKUP
54#define USE_SIMPLE_HASH_TABLE_LOOKUP
55#endif
56
57#ifndef TEST_NAMESPACE_RESOLVER
58#define TEST_NAMESPACE_RESOLVER
59#endif
60
61#ifndef TEST_CUCKOO_HASH_TABLE
62#define TEST_CUCKOO_HASH_TABLE
63#endif
64
65#ifndef TEST_PER_SYMBOL_ELEM_DECL_LISTS
66#define TEST_PER_SYMBOL_ELEM_DECL_LISTS
67#endif
68
69#if !defined(STORE_CHILDREN_INFORMATION_IN_PARSER)
70#define STORE_CHILDREN_INFORMATION_IN_PARSER
71#endif
72
73#if !defined(PERFORM_ELEMENT_STACK_MATCHING_IN_PARSER)
74#define PERFORM_ELEMENT_STACK_MATCHING_IN_PARSER
75#endif
76
77#if !defined(TEST_ENTITY_EXPANSION)
78#define TEST_ENTITY_EXPANSION
79#endif
80
81#if !defined(INTERGRATE_SYMBOL_RESOLUTION_INTO_CHARACTER_SET_ADAPTER)
82#define INTERGRATE_SYMBOL_RESOLUTION_INTO_CHARACTER_SET_ADAPTER
83#endif
84
85#if !defined(CALCULATE_COPY_BACK_POSITION)
86 //#define CALCULATE_COPY_BACK_POSITION
87#endif
88
89#if !defined(USE_UTF16_BIG_ENDIAN)
90// #define USE_UTF16_BIG_ENDIAN
91#endif
92
93#if !defined(ICXML_ENABLE_VERSION1_1)
94#define ICXML_ENABLE_VERSION1_1  // to safely turn this on, any symbol ending with a NEL must be 'truncated' to remove the erroneous bytes.
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#ifndef SEPERATE_DOC_HANDLING_FROM_GRAMMAR_VALIDATION
106#define SEPERATE_DOC_HANDLING_FROM_GRAMMAR_VALIDATION
107#endif
108
109#ifdef __ARCH_64
110#undef __ARCH_64
111#endif
112
113#if defined (_MSC_VER) && defined(_M_X64)
114#define __ARCH_64
115#elif defined (__GNUC__) && defined(__x86_64__)
116#define __ARCH_64
117#endif
118
119#ifdef __ARCH_X86
120#undef __ARCH_X86
121#endif
122
123#if defined(_MSC_VER) && defined(_M_X86)
124    #define __ARCH_X86
125#elif defined (__GNUC__) && (defined(__i386__) || defined(__arm__))
126    #define __ARCH_X86
127#endif
128
129/* does nothing so far; there is an advantage in replacing the internal attr list functionality
130   with a more refined one--but this will require modifying the /internal/VecAttrListImpl and
131   /internal/VecAttributesImpl classes to support the new type */
132//#define REPLACE_INTERNAL_SCANNER_ATTRIBUTE_LIST
133
134#ifndef XML_CONFIG_HPP_GUARD
135#define XML_CONFIG_HPP_GUARD
136
137        #include <simd-lib/bitblock.hpp>
138    #include <icxmlc/endian.h>
139    //#include <PapiCounter.hpp>
140
141    #if defined(BOOST_LITTLE_ENDIAN)
142    #define BYTE_OFFSET(x) (x)
143    #elif defined(BOOST_BIG_ENDIAN)
144    #define BYTE_OFFSET(x) (3 - x)
145    #elif defined(BOOST_PDP_ENDIAN)
146    #define BYTE_OFFSET(x) ((x + 2) & 3)
147    #endif
148
149    typedef ScanWord scanword_t;
150    typedef ScanWord iterator_t;
151
152        #include <icxmlc/clog2.h>
153        #include <cstddef>
154
155        enum
156        {
157                LOG_2_BLOCK_SIZE = CONST_LOG_2(BLOCK_SIZE)
158        };
159
160    template <size_t CodeUnitSize> struct CharType
161    {
162        typedef size_t T;  //default for CharType::T is size_t
163    };
164
165    template <> struct CharType<0> {typedef XMLByte T;};
166    template <> struct CharType<1> {typedef XMLByte T;};
167    template <> struct CharType<2> {typedef XMLCh T;};
168    template <> struct CharType<3> {typedef XMLUInt32 T;};
169    template <> struct CharType<4> {typedef XMLUInt32 T;};
170
171        /************************************ BUFFER SIZE CONFIGURATIONS **************************************/
172
173    #ifndef SEGMENT_SIZE
174    #define SEGMENT_SIZE (16 * 1024)
175    #endif
176
177    #define BUFFER_BLOCKS (SEGMENT_SIZE / BLOCK_SIZE)
178
179//    #define STRING2(x) #x
180//    #define STRING(x) STRING2(x)
181//    #pragma message "XMLConfig::SEGMENT_SIZE = " STRING(SEGMENT_SIZE)
182
183    #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
184
185        #define INITIAL_SYMBOL_TABLE_STRING_POOL_SIZE (1024)
186
187        #define INITIAL_MAX_SCOPE 16
188
189        #define EXPECTED_LEAF_NODE_COUNT 32
190
191        #define INITIAL_ATTRIBUTE_LIST_SIZE 16
192
193        #define INITIAL_NAMESPACE_RESOLVER_STRING_POOL_SIZE 2048
194
195        #define GET_CONTEXT_ID_FOR_EACH_ELEMENT
196
197    typedef CharType<(CONST_LOG_2(BUFFER_BLOCKS) + 23) / 24>::T MarkupCountType; // 24 = bits per byte (8) * minimum length of any piece of markup (3)
198
199    #if ((SEGMENT_SIZE * 2) <= 0xFF)
200    typedef int8_t LineColumnDiffType;
201    #elif ((SEGMENT_SIZE * 2) <= 0xFFFF)
202    typedef int16_t LineColumnDiffType;
203    #elif ((SEGMENT_SIZE * 2) <= 0xFFFFFFFF)
204    typedef int32_t LineColumnDiffType;
205    #else
206    typedef int64_t LineColumnDiffType;
207    #define LINE_COLUMN_TRACKER_USES_RAW_NUMBERS
208    #endif
209
210        /* PREFETCH */
211        #ifdef __GNUC__
212                #define PREFETCH(x) __builtin_prefetch((void*)(x));
213        #elif defined _MSC_VER
214                #define PREFETCH(x) _mm_prefetch((char*)(x), _MM_HINT_NTA);
215        #else
216                #define PREFETCH(x)
217        #endif
218
219        /* UNREACHABLE */
220        #ifdef _DEBUG
221                #define UNREACHABLE assert(!"UNREACHABLE CODE EXECUTED!");
222        #elif defined(__GNUC__)
223                // built-in unreachable is only valid from gcc 4.5 and above
224                #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
225                #define UNREACHABLE __builtin_unreachable(); // requires -Wunreachable-code?
226                #else
227                #define UNREACHABLE abort();
228                #endif
229        #elif defined _MSC_VER
230                #define UNREACHABLE __assume(0);
231        #else
232                #define UNREACHABLE
233        #endif
234
235        /* ASSUME */
236        #ifdef __GNUC__
237                // built-in unreachable is only valid from gcc 4.5 and above
238                #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
239                #define ASSUME(cond) // do { if (!(cond)) { UNREACHABLE } } while (0);
240                #else
241                #define ASSUME(cond)
242                #endif
243        #elif defined _MSC_VER
244                #define ASSUME(cond) __assume(cond);
245        #else
246                #define ASSUME(cond)
247        #endif
248
249    /* IS_CONST_EXPR */
250    #ifdef __GNUC__
251        #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 0)
252            #define CONST_EXPR(x) (__builtin_constant_p(x) && (x))
253        #else
254            #define CONST_EXPR(x) (x)
255        #endif
256    #elif defined _MSC_VER
257        #define CONST_EXPR(x) (x) // ??
258    #else
259        #define CONST_EXPR(x) (x)
260    #endif
261
262        /* DEPRECATED_FEATURE_IN_ICXML */
263        #ifdef SHOW_CALLSTACK_FOR_DEPRECATED_FEATURES
264                #include <icxmlc/backtrace.h>
265                #define DEPRECATED_FEATURE_IN_ICXML assert(deprecatedFeatureUsed()); throw;
266        #else
267                #define DEPRECATED_FEATURE_IN_ICXML throw;/* TODO: create xerces-compatible exception to throw */
268        #endif
269
270        #ifdef USE_SIMPLE_HASH_TABLE_LOOKUP
271                typedef uint32_t gid_t;
272        #else
273                #include <icxmlc/symbol_table/src/gid.hpp>
274                typedef gid_type gid_t;
275        #endif
276
277        #ifdef PRINT_DEBUG_MESSAGE
278
279                #include <icxercesc/util/XMLString.hpp>
280                #include <iostream>
281                #include <iomanip>
282
283                #define DEBUG_MESSAGE(MSG) \
284                        try \
285                        { \
286                                XERCES_STD_QUALIFIER clog << MSG << XERCES_STD_QUALIFIER endl; \
287                        } \
288                        catch (...) \
289                        { \
290                                XERCES_STD_QUALIFIER clog << "!! DEBUG MESSAGE ERROR: " << __FILE__ << "." << __LINE__ << " !!" << XERCES_STD_QUALIFIER endl; \
291                                exit(-2); \
292                        }
293
294        XERCES_CPP_NAMESPACE_BEGIN
295
296        template<typename Char>
297        static inline std::ostream & __printKey(std::ostream & out, const Char * key, const size_t length)
298        {
299            Char keyBuf[1024] = {0};
300            const size_t keyLen = length < 1024 ? length : 1023;
301            memcpy(keyBuf, key, keyLen);
302            out << keyBuf;
303            return out;
304        }
305
306        inline static std::ostream & operator << (std::ostream & out, const XMLCh * const string)
307                {
308                        if (string)
309                        {
310                                try
311                                {
312                    char buf[1024] = {'"', 0};
313                    const XMLCh * inputPtr = string;
314
315                    const char HEX[16] = { '0', '1', '2', '3', '4', '5', '6', '7'
316                                         , '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
317
318                    char * outputPtr = &buf[1];
319
320                    bool done = false;
321
322                    do
323                    {
324                        size_t count = 128;
325
326                        while (count--)
327                        {
328                            size_t ch = *inputPtr++;
329
330                            if (unlikely(ch < 0x0020 || ch > 0x007F))
331                            {
332                                if (ch == 0)
333                                {
334                                    done = true;
335                                    break;
336                                }
337                                size_t i = 0;
338                                char hexval[4];
339                                while (ch)
340                                {
341                                    hexval[i++] = HEX[ch & 15];
342                                    ch >>= 4;
343                                }
344                                *outputPtr++ = '\\';
345                                while (i--)
346                                {
347                                    *outputPtr++ = hexval[i];
348                                }
349                            }
350                            else
351                            {
352                                *outputPtr++ = static_cast<char>(ch);
353                            }
354                        }
355
356                        if (done)
357                        {
358                            *outputPtr++ = '"';
359                        }
360                        *outputPtr = 0;
361                        out << &buf[0];
362
363                        outputPtr = &buf[0];
364                    }
365                    while (!done);
366                                }
367                                catch (std::exception & e)
368                                {
369                                        out << '|' << e.what() << '|';
370                                }
371                                catch (...)
372                                {
373                                        /* do nothing */
374                                }
375                        }
376                        return out;
377                }
378
379                inline static std::ostream & operator << (std::ostream & out, const BytePack & block)
380                {
381            char output[sizeof(BytePack) * 3 + 1] = {0};
382
383                        const char hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7'
384                                 , '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
385
386                        ubitblock value;
387                        value._128 = block;
388
389            for(size_t i = 0; i < sizeof(BytePack); i++)
390                        {
391                                const char c = value._8[i];
392                                const size_t offset = (sizeof(BytePack) - 1 - i) * 3;
393                                output[offset] = hex[(c & 0xF0) >> 4];
394                                output[offset + 1] = hex[c & 0x0F];
395                                output[offset + 2] = ' ';
396            }
397            output[sizeof(BytePack) * 3] = 0;
398
399                        out << output;
400
401                        return out;
402                }
403
404        XERCES_CPP_NAMESPACE_END
405
406        template <>
407        inline void print_register<BitBlock>(const char * var_name, BitBlock v)
408        {
409            char output[sizeof(BytePack) * 3 + 1] = {0};
410
411            const char hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7'
412                                 , '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
413
414            ubitblock value;
415            value._128 = v;
416
417            for(size_t i = 0; i < sizeof(BytePack); i++)
418            {
419                const char c = value._8[i];
420                const size_t offset = (sizeof(BytePack) - 1 - i) * 3;
421                output[offset] = hex[(c & 0xF0) >> 4];
422                output[offset + 1] = hex[c & 0x0F];
423                output[offset + 2] = ' ';
424            }
425            output[sizeof(BytePack) * 3] = 0;
426
427            std::clog << std::setw(40) << var_name << std::setw(0) << " = " << output << std::endl;
428        }
429
430        template <>
431        inline void print_register<ScanWord>(const char * var_name, ScanWord v)
432        {
433            char output[sizeof(ScanWord) * 3 + 1] = {0};
434
435            const char hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7'
436                                 , '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
437
438            union ScanWordArray {
439                ScanWord _sw;
440                uint8_t _8[sizeof(ScanWord)/sizeof(uint8_t)];
441            };
442
443
444            ScanWordArray value;
445            value._sw = v;
446
447            for(size_t i = 0; i < sizeof(ScanWord); i++)
448            {
449                const char c = value._8[i];
450                const size_t offset = (sizeof(ScanWord) - 1 - i) * 3;
451                output[offset] = hex[(c & 0xF0) >> 4];
452                output[offset + 1] = hex[c & 0x0F];
453                output[offset + 2] = ' ';
454            }
455            output[sizeof(ScanWord) * 3] = 0;
456
457            std::clog << std::setw(40) << var_name << std::setw(0) << " = " << output << std::endl;
458        }
459
460        #else
461                #define DEBUG_MESSAGE(MSG)
462        #endif
463
464        #if !defined(PRINT_DEBUG_IGNORE_TRANSITION_STREAM_MESSAGES)
465                #define DEBUG_TRANSITION_MESSAGE(MSG) DEBUG_MESSAGE(MSG)
466        #else
467                #define DEBUG_TRANSITION_MESSAGE(MSG)
468        #endif
469
470        #if !defined(PRINT_DEBUG_IGNORE_GRAMMAR_MESSAGES)
471                #define DEBUG_GRAMMAR_MESSAGE(MSG) DEBUG_MESSAGE(MSG)
472        #else
473                #define DEBUG_GRAMMAR_MESSAGE(MSG)
474        #endif
475
476        #if !defined(PRINT_DEBUG_IGNORE_NAMESPACE_MESSAGES)
477                #define DEBUG_NAMESPACE_MESSAGE(MSG) DEBUG_MESSAGE(MSG)
478        #else
479                #define DEBUG_NAMESPACE_MESSAGE(MSG)
480        #endif
481
482    #if !defined(PRINT_DEBUG_IGNORE_SYMBOL_STREAM_MESSAGES)
483        #define DEBUG_SYMBOL_MESSAGE(MSG) DEBUG_MESSAGE(MSG)
484    #else
485        #define DEBUG_SYMBOL_MESSAGE(MSG)
486    #endif
487
488    #if !defined(PRINT_DEBUG_IGNORE_REFERENCE_STREAM_MESSAGES)
489        #define DEBUG_REFERENCE_MESSAGE(MSG) DEBUG_MESSAGE(MSG)
490    #else
491        #define DEBUG_REFERENCE_MESSAGE(MSG)
492    #endif
493
494    #if !defined(PRINT_DEBUG_IGNORE_WELL_FORMEDNESS_MESSAGES)
495        #define DEBUG_WELL_FORMEDNESS_MESSAGE(MSG) DEBUG_MESSAGE(MSG)
496    #else
497        #define DEBUG_WELL_FORMEDNESS_MESSAGE(MSG)
498    #endif
499
500        IDISA_ALWAYS_INLINE
501        static BitBlock maskli(const uint64_t position)
502        {
503                return bitblock::sll(simd<1>::constant<1>(), convert(position));
504        }
505
506        IDISA_ALWAYS_INLINE
507        static BitBlock maskre(const uint64_t position)
508        {
509                return simd_not(maskli(position));
510        }
511
512        IDISA_ALWAYS_INLINE
513        static BitBlock maskri(const uint64_t position)
514        {
515                return bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE - 1 - position));
516        }
517
518        IDISA_ALWAYS_INLINE
519        static BitBlock maskle(const uint64_t position)
520        {
521                return simd_not(maskri(position));
522        }
523
524        IDISA_ALWAYS_INLINE
525        static void load_fence()
526        {
527                #ifndef IGNORE_CACHE_BYPASS
528                _mm_lfence();
529                #endif
530        }
531
532        IDISA_ALWAYS_INLINE
533        static void store_fence()
534        {
535                #ifndef IGNORE_CACHE_BYPASS
536                _mm_mfence();
537                #endif
538        }
539
540
541#endif
Note: See TracBrowser for help on using the repository browser.