/xmlbench/trunk

To get this branch, use:
bzr branch http://darksoft.org/webbzr/xmlbench/trunk

« back to all changes in this revision

Viewing changes to parse/parabix.20090922/src/xmldecl.h

  • Committer: Suren A. Chilingaryan
  • Date: 2009-09-23 17:13:04 UTC
  • Revision ID: csa@dside.dyndns.org-20090923171304-osvtr4zqb29h11kd
Intel, Tango, Phobos, and RapidXML parsers; Memory benchmark scripts

Show diffs side-by-side

added added

removed removed

Lines of Context:
parse/parabix.20090922/src/xmldecl.h
 
1
/*  xmldecl.h - Parsing XML and text declarations.
 
2
    Copyright (c) 2008,  Robert D. Cameron.
 
3
    Licensed to the public under the Open Software License 3.0.
 
4
    Licensed to International Characters, Inc., under the Academic
 
5
    Free License 3.0.
 
6
 
 
7
*/
 
8
#ifndef XML_DECL_H
 
9
#define XML_DECL_H
 
10
 
 
11
enum XML_version {XML_1_0, XML_1_1, no_XML_version_value};
 
12
/* Documents may be encoded in accord with either XML 1.0 or XML 1.1,
 
13
   or there may be no XML version declared ("no value" in the 
 
14
   XML infoset parlance). */
 
15
 
 
16
enum CodeUnit_Base {ASCII, EBCDIC};
 
17
 
 
18
/* Code units of the underlying character set may be either ASCII-compatible
 
19
   or EBCDIC-compatible.
 
20
   ASCII-compatibility means that any code units satisfy the following properties.
 
21
     (1) Any code unit whose numeric value is in the ASinclude "byteplex.h"CII range (0 to 0x7F)
 
22
         is a complete character sequence (single code unit sequence) representing
 
23
         that ASCII character.
 
24
     (2) Any code units above the ASCII range are non-ASCII code units.
 
25
         No code units or code unit sequences containing a non-ASCII code unit
 
26
         may represent an ASCII character.  (This property ensures that 
 
27
         non-ASCII code units may be ignored in making ASCII-based parsing decisions).
 
28
   EBCDIC-compatible, for the purposes of XML, means that the following property
 
29
         applies.include "byteplex.h"
 
30
 
 
31
     (*) Code units may form all or part of a code unit sequence representing
 
32
         a character in the Unicode range 0 to 0x9F if and only if that code
 
33
         unit has the same interpretation unde the basic EBCDIC code page cp037.
 
34
*/
 
35
 
 
36
enum CodeUnit_Size {SingleByte = 1, DoubleByte = 2, QuadByte = 4};
 
37
/* ASCII, EBCDIC, ISO-8859-X and UTF-8 have 8-bit code units (singlebytes);
 
38
   The UTF-16 and UCS-2 families have 16-bit code units (doublebyte);
 
39
   The UTF-32/UCS-4 family has 32-bit code units. */
 
40
 
 
41
enum CodeUnit_ByteOrder {BigEndian, LittleEndian, Unusual_3412, Unusual_2143};
 
42
/* The byte order of 16-bit or 32-bit code units.  The possibilities are:
 
43
   BigEndian:  UTF-16BE, UCS-2BE, UTF-16 or UCS-2 with a BigEndian byte order mark,
 
44
               UTF-16 without a byte order mark, 
 
45
               UTF-32BE/UCS-4BE, or UTF-32/UCS-4 with a BigEndian byte order mark.
 
46
   LittleEndian: UTF-16LE, UCS-2LE, UTF-16 or UCS-2 with a LittleEndian byte order mark.
 
47
                 UTF-32LE/UCS-4LE, or UTF-32/UCS-4 with a LittleEndian byte order mark.
 
48
   Unusual_3412: Unusual octet order of UTF-32/UCS-4 with byte order mark FE FF 00 00
 
49
   Unusual_2143: Unusual octet order of UTF-32/UCS-4 with byte order mark 00 00 FF FE.
 
50
*/
 
51
 
 
52
enum XML_standalone {Standalone_yes, Standalone_no, Standalone_no_value};
 
53
/* Possible values depending on the optional standalone component of an 
 
54
   XML declaration. */
 
55
 
 
56
class Entity_Info {
 
57
        
 
58
public: 
 
59
        Entity_Info();
 
60
        ~Entity_Info();
 
61
 
 
62
        /*  Information computed by analyzing the 4-byte initial signature
 
63
            of an XML document. */
 
64
        int BOM_units; /* no of initial code units for a Byte Order Mark */
 
65
 
 
66
        CodeUnit_Base code_unit_base;
 
67
        CodeUnit_Size code_unit_size;
 
68
        CodeUnit_ByteOrder byte_order;  
 
69
 
 
70
        void AnalyzeSignature(unsigned char * signature);
 
71
 
 
72
        /* Information computed from the XML or text declaration. */
 
73
        XML_version version;
 
74
        bool has_encoding_decl;
 
75
        unsigned char * encoding;
 
76
        XML_standalone standalone;
 
77
        int content_start;  /* position after BOM and XML/text decl.*/
 
78
        
 
79
private:
 
80
        void set_charset_family(CodeUnit_Base C, CodeUnit_Size S, CodeUnit_ByteOrder O, int B);
 
81
};
 
82
 
 
83
 
 
84
#include "byteplex.h"
 
85
 
 
86
template <CodeUnit_Base C>
 
87
class XML_Decl_Parser {
 
88
public:
 
89
        XML_Decl_Parser (Byteplex * b);
 
90
        ~XML_Decl_Parser ();
 
91
        
 
92
        void ReadXMLInfo(Entity_Info & e);
 
93
        void ReadTextDeclaration(Entity_Info & e);
 
94
        // Generic version if type of external entity unknown.
 
95
        void ReadXMLorTextDecl(Entity_Info & e);
 
96
        
 
97
 
 
98
protected:
 
99
 
 
100
        Byteplex * byteplex;
 
101
        unsigned char * x8data;
 
102
        int buffer_base_pos;
 
103
        int buffer_rel_pos;
 
104
        int buffer_limit_pos;
 
105
        
 
106
        void Advance(int n);
 
107
        int AbsPos() const;
 
108
        unsigned char * cur() const;
 
109
        
 
110
private:
 
111
        /* Bytespace parsing routines for internal use in ReadXMLInfo and
 
112
           ReadTextDeclaration. */
 
113
        void DeclError();
 
114
        void Scan_WS();
 
115
        void ScanToQuote();
 
116
        void ParseVersion(Entity_Info & e);
 
117
        void ParseEncoding(Entity_Info & e);
 
118
        void ParseStandalone(Entity_Info & e);
 
119
 
 
120
};
 
121
#endif