react-native-quick-crypto 1.0.19 → 1.1.0

package/deps/simdutf/benchmarks/competition/u8u16/src/xml_error.c

@@ -0,0 +1,193 @@
+/*  xml_error.c - Error reporting for XML parsing/validation.
+    Copyright (c) 2008, Robert D. Cameron and Dan Lin.
+    Licensed to the public under the Open Software License 3.0.
+    Licensed to International Characters, Inc., under the Academic
+    Free License 3.0.
+*/
+
+#include "xml_error.h"
+char * XML_Constraint_Strings[] = {
+		"wfc-PEinInternalSubset",
+		"ExtSubset",
+		"PE-between-Decls",
+		"GIMatch",
+		"uniqattspec",
+		"NoExternalRefs",
+		"CleanAttrVals",
+		"wf-Legalchar",
+		"wf-entdeclared",
+		"textent",
+		"norecursion",
+		"indtd",
+		"vc-roottype",
+		"vc-PEinMarkupDecl",
+		"vc-check-rmd",
+		"elementvalid",
+		"ValueType",
+		"EDUnique",
+		"vc-PEinGroup",
+		"vc-MixedChildrenUnique",
+		"id",
+		"one-id-per-el",
+		"id-default",
+		"idref",
+		"entname",
+		"nmtok",
+		"notatn",
+		"OneNotationPer",
+		"NoNotationEmpty",
+		"NoDuplicateTokens",
+		"enum",
+		"RequiredAttr",
+		"defattrvalid",
+		"FixedAttr",
+		"condsec-nesting",
+		"vc-entdeclared",
+		"not-declared",
+		"UniqueNotationName"};
+
+char * XML_NonTerminal_Names[] = {
+		"document  [1]",
+		"Char  [2]",
+		"S  [3]",
+		"NameChar  [4]",
+		"Name  [5]",
+		"Names  [6]",
+		"Nmtoken  [7]",
+		"Nmtokens  [8]",
+		"EntityValue  [9]",
+		"AttValue  [10]",
+		"SystemLiteral  [11]",
+		"PubidLiteral  [12]",
+		"PubidChar  [13]",
+		"CharData  [14]",
+		"Comment  [15]",
+		"PI  [16]",
+		"PITarget  [17]",
+		"CDSect  [18]",
+		"CDStart  [19]",
+		"CData  [20]",
+		"CDEnd  [21]",
+		"prolog  [22]",
+		"XMLDecl  [23]",
+		"VersionInfo  [24]",
+		"Eq  [25]",
+		"VersionNum  [26]",
+		"Misc  [27]",
+		"doctypedecl  [28]",
+		"DeclSep  [28a]",
+		"intSubset  [28b]",
+		"markupdecl  [29]",
+		"extSubset  [30]",
+		"extSubsetDecl  [31]",
+		"SDDecl  [32]",
+		"element  [39]",
+		"STag  [40]",
+		"Attribute  [41]",
+		"ETag  [42]",
+		"content  [43]",
+		"EmptyElemTag  [44]",
+		"elementdecl  [45]",
+		"contentspec  [46]",
+		"children  [47]",
+		"cp  [48]",
+		"choice  [49]",
+		"seq  [50]",
+		"Mixed  [51]",
+		"AttlistDecl  [52]",
+		"AttDef  [53]",
+		"AttType  [54]",
+		"StringType  [55]",
+		"TokenizedType  [56]",
+		"EnumeratedType  [57]",
+		"NotationType  [58]",
+		"Enumeration  [59]",
+		"DefaultDecl  [60]",
+		"conditionalSect  [61]",
+		"includeSect  [62]",
+		"ignoreSect  [63]",
+		"ignoreSectContents  [64]",
+		"Ignore  [65]",
+		"CharRef  [66]",
+		"Reference  [67]",
+		"EntityRef  [68]",
+		"PEReference  [69]",
+		"EntityDecl  [70]",
+		"GEDecl  [71]",
+		"PEDecl  [72]",
+		"EntityDef  [73]",
+		"PEDef  [74]",
+		"ExternalID  [75]",
+		"NDataDecl  [76]",
+		"TextDecl  [77]",
+		"extParsedEnt  [78]",
+		"EncodingDecl  [80]",
+		"EncName  [81]",
+		"NotationDecl  [82]",
+		"PublicID  [83]",
+		"Letter  [84]",
+		"BaseChar  [85]",
+		"Ideographic  [86]",
+		"CombiningChar  [87]",
+		"Digit  [88]",
+		"Extender  [89]"};
+
+
+void ShowConstraintError(XML_Constraint errCode) {
+	if (errCode < vErr_vc_roottype) {
+		fprintf(stderr, "Violation of well-formedness constraint: %s\n", XML_Constraint_Strings[errCode]);
+		exit(-1);
+	}
+	else {
+		fprintf(stderr, "Violation of validity constraint: %s\n", XML_Constraint_Strings[errCode]);
+		exit(-1);
+	}
+}
+
+void ShowSyntaxError(XML_NonTerminal errCode) {
+	fprintf(stderr, "Syntax error in production: %s\n", XML_NonTerminal_Names[errCode]);
+}
+
+
+void NoEncodingError(char * msg) {
+	fprintf(stderr, "Error : %s\n", msg);
+	exit(-1);
+}
+
+void EncodingError(char * msg, unsigned char * encoding, int lgth) {
+	fprintf(stderr, "Error : Illegal/unsupported %s encoding of length %i: \"", msg, lgth);
+	for (int i = 0; i < lgth; i++) fprintf(stderr, "%c", encoding[i]);
+	fprintf(stderr, "\"\n"); 
+	exit(-1);
+}
+
+void CharSetValidationError(char * encoding, int err_pos) {
+	fprintf(stderr, "Error: Invalid %s character in input stream at position %i\n", encoding, err_pos);
+	exit(-1);
+}
+
+void XMLCharacterError(int err_pos) {
+	fprintf(stderr, "Illegal control character in XML input stream at position %i\n", err_pos);
+	exit(-1);
+}
+
+void IncompleteCodeUnitError() {
+	fprintf(stderr, "Error: Incomplete code unit at end of file.\n");
+	exit(-1);
+}
+
+void DeclarationError(int pos) {
+	fprintf(stderr, "Parsing error at position %i in XML or Text declaration.\n", pos);
+	exit(-1);
+}
+
+void ImplementationLimitError(char * msg) {
+	fprintf(stderr, "Fatal implementation limit - %s\n", msg);
+	exit(-1);
+}
+
+void ContentModelError() {
+	fprintf(stderr, "Error: nondeterminism in content model.\n");
+	exit(-1);
+}
+

package/deps/simdutf/benchmarks/competition/u8u16/src/xml_error.h

@@ -0,0 +1,167 @@
+/*  xml_error.h - Error codes for XML parsing/validation.
+    Copyright (c) 2008, Robert D. Cameron and Dan Lin.
+    Licensed to the public under the Open Software License 3.0.
+    Licensed to International Characters, Inc., under the Academic
+    Free License 3.0.
+
+   The following enum provides codes for the well-formedness (wfErr)
+   and validity (vErr) constraints of XML, based on the ids for those
+   constraints in the REC-xml-20060816.xml document.  The ids may be
+   recovered by stripping wfErr_ or vc_Err and substituting "-" for "_".
+*/
+#ifndef XML_ERROR_H
+#define XML_ERROR_H
+
+enum XML_Constraint {
+		wfErr_wfc_PEinInternalSubset,
+		wfErr_ExtSubset,
+		wfErr_PE_between_Decls,
+		wfErr_GIMatch,
+		wfErr_uniqattspec,
+		wfErr_NoExternalRefs,
+		wfErr_CleanAttrVals,
+		wfErr_wf_Legalchar,
+		wfErr_wf_entdeclared,
+		wfErr_textent,
+		wfErr_norecursion,
+		wfErr_indtd,
+		vErr_vc_roottype,
+		vErr_vc_PEinMarkupDecl,
+		vErr_vc_check_rmd,
+		vErr_elementvalid,
+		vErr_ValueType,
+		vErr_EDUnique,
+		vErr_vc_PEinGroup,
+		vErr_vc_MixedChildrenUnique,
+		vErr_id,
+		vErr_one_id_per_el,
+		vErr_id_default,
+		vErr_idref,
+		vErr_entname,
+		vErr_nmtok,
+		vErr_notatn,
+		vErr_OneNotationPer,
+		vErr_NoNotationEmpty,
+		vErr_NoDuplicateTokens,
+		vErr_enum,
+		vErr_RequiredAttr,
+		vErr_defattrvalid,
+		vErr_FixedAttr,
+		vErr_condsec_nesting,
+		vErr_vc_entdeclared,
+		vErr_not_declared,
+		vErr_UniqueNotationName};
+
+
+/* The following enum provides codes for XML nonterminals using
+   codes in the REC-xml-20060816.xml document.  The ids may be
+   recovered by substituting "-" for "_".
+*/
+
+enum XML_NonTerminal {
+		NT_document,
+		NT_Char,
+		NT_S,
+		NT_NameChar,
+		NT_Name,
+		NT_Names,
+		NT_Nmtoken,
+		NT_Nmtokens,
+		NT_EntityValue,
+		NT_AttValue,
+		NT_SystemLiteral,
+		NT_PubidLiteral,
+		NT_PubidChar,
+		NT_CharData,
+		NT_Comment,
+		NT_PI,
+		NT_PITarget,
+		NT_CDSect,
+		NT_CDStart,
+		NT_CData,
+		NT_CDEnd,
+		NT_prolog,
+		NT_XMLDecl,
+		NT_VersionInfo,
+		NT_Eq,
+		NT_VersionNum,
+		NT_Misc,
+		NT_doctypedecl,
+		NT_DeclSep,
+		NT_intSubset,
+		NT_markupdecl,
+		NT_extSubset,
+		NT_extSubsetDecl,
+		NT_SDDecl,
+		NT_element,
+		NT_STag,
+		NT_Attribute,
+		NT_ETag,
+		NT_content,
+		NT_EmptyElemTag,
+		NT_elementdecl,
+		NT_contentspec,
+		NT_children,
+		NT_cp,
+		NT_choice,
+		NT_seq,
+		NT_Mixed,
+		NT_AttlistDecl,
+		NT_AttDef,
+		NT_AttType,
+		NT_StringType,
+		NT_TokenizedType,
+		NT_EnumeratedType,
+		NT_NotationType,
+		NT_Enumeration,
+		NT_DefaultDecl,
+		NT_conditionalSect,
+		NT_includeSect,
+		NT_ignoreSect,
+		NT_ignoreSectContents,
+		NT_Ignore,
+		NT_CharRef,
+		NT_Reference,
+		NT_EntityRef,
+		NT_PEReference,
+		NT_EntityDecl,
+		NT_GEDecl,
+		NT_PEDecl,
+		NT_EntityDef,
+		NT_PEDef,
+		NT_ExternalID,
+		NT_NDataDecl,
+		NT_TextDecl,
+		NT_extParsedEnt,
+		NT_EncodingDecl,
+		NT_EncName,
+		NT_NotationDecl,
+		NT_PublicID,
+		NT_Letter,
+		NT_BaseChar,
+		NT_Ideographic,
+		NT_CombiningChar,
+		NT_Digit,
+		NT_Extender};
+
+
+void ShowConstraintError(XML_Constraint errCode);
+
+void ShowSyntaxError(XML_NonTerminal errCode);
+
+void NoEncodingError(char * msg);
+
+void EncodingError(char * msg, unsigned char * encoding, int lgth);
+
+void CharSetValidationError(char * encoding, int err_pos);
+
+void XMLCharacterError(int err_pos);
+
+void IncompleteCodeUnitError();
+
+void DeclarationError(int pos);
+
+void ImplementationLimitError(char * msg);
+
+void ContentModelError();
+#endif

package/deps/simdutf/benchmarks/competition/u8u16/src/xmldecl.c

@@ -0,0 +1,288 @@
+/*  xmldecl.c - Parsing XML and Text Declarations.
+    Copyright (c) 2008, Robert D. Cameron.
+    Licensed to the public under the Open Software License 3.0.
+    Licensed to International Characters, Inc., under the Academic
+    Free License 3.0.
+
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+
+#include "xmldecl.h"
+#include "xml_error.h"
+#include "multiliteral.h"
+#include "bytelex.h"
+
+
+Entity_Info::Entity_Info() {
+	encoding = NULL;
+}
+Entity_Info::~Entity_Info() {
+	delete [] encoding;
+}
+
+/* Signature-based character set family detection in accord with
+   Appendix F of the XML 1.0 and 1.1 specifications. */
+
+/* These definitions use b2int16 to determine appropriate doublebyte
+   values based on endianness of the underlying architecture. */
+static const int x0000 = b2int16<0x00, 0x00>::value;
+static const int xFEFF = b2int16<0xFE, 0xFF>::value;
+static const int xFFFE = b2int16<0xFF, 0xFE>::value;
+static const int x003C = b2int16<0x00, 0x3C>::value;
+static const int x3C00 = b2int16<0x3C, 0x00>::value;
+static const int x4C6F = b2int16<0x4C, 0x6F>::value;
+static const int xA794 = b2int16<0xA7, 0x94>::value;
+static const int xEFBE = b2int16<0xEF, 0xBE>::value;
+
+void Entity_Info::AnalyzeSignature(unsigned char * signature) {
+ 	uint16_t * XML_dbl_byte = (uint16_t *) signature;
+	switch (XML_dbl_byte[0]) {
+		case x0000:
+			switch (XML_dbl_byte[1]) {
+				case xFEFF: set_charset_family(ASCII, QuadByte, BigEndian, 1);break;
+				case xFFFE: set_charset_family(ASCII, QuadByte, Unusual_2143, 1);break;
+				case x3C00: set_charset_family(ASCII, QuadByte, Unusual_2143, 0);break;
+				default: set_charset_family(ASCII, QuadByte, BigEndian, 0);
+			}
+			break;
+		case xFEFF:
+			if (XML_dbl_byte[1] == x0000)
+				set_charset_family(ASCII, QuadByte, Unusual_3412, 1);
+			else set_charset_family(ASCII, DoubleByte, BigEndian, 1);
+			break;
+		case xFFFE:
+			if (XML_dbl_byte[1] == x0000)
+				set_charset_family(ASCII, QuadByte, LittleEndian, 1);
+			else set_charset_family(ASCII, DoubleByte, LittleEndian, 1);
+			break;
+		case x003C:
+			if (XML_dbl_byte[1] == x0000)
+				set_charset_family(ASCII, QuadByte, Unusual_3412, 0);
+			else set_charset_family(ASCII, DoubleByte, BigEndian, 0);
+			break;
+		case x3C00:
+			if (XML_dbl_byte[1] == x0000)
+				set_charset_family(ASCII, QuadByte, LittleEndian, 0);
+			else set_charset_family(ASCII, DoubleByte, LittleEndian, 0);
+			break;
+		case x4C6F:
+			if (XML_dbl_byte[1] == xA794)
+				set_charset_family(EBCDIC, SingleByte, BigEndian, 0);
+			else set_charset_family(ASCII, SingleByte, BigEndian, 0);
+			break;
+		case xEFBE:
+			if (signature[2] == 0xBF)
+				set_charset_family(ASCII, SingleByte, BigEndian, 3);
+			else set_charset_family(ASCII, SingleByte, BigEndian, 0);
+			break;
+		default:
+			set_charset_family(ASCII, SingleByte, BigEndian, 0);
+	}
+}
+void Entity_Info::set_charset_family(CodeUnit_Base C, CodeUnit_Size S, CodeUnit_ByteOrder O, int B){
+ 		code_unit_base = C;
+ 		code_unit_size = S;
+ 		byte_order = O;
+ 		BOM_units = B;
+ }
+
+
+XML_Decl_Parser::XML_Decl_Parser(unsigned char * bytes){
+	buffer_base_pos = 0;
+	x8data = bytes;
+}
+
+XML_Decl_Parser::~XML_Decl_Parser(){
+}
+
+inline void XML_Decl_Parser::DeclError() {
+	DeclarationError(AbsPos());
+}
+
+inline int XML_Decl_Parser::AbsPos() const {
+	return 	buffer_base_pos + buffer_rel_pos;
+}
+
+inline unsigned char * XML_Decl_Parser::cur() const {
+	return &x8data[buffer_rel_pos];
+}
+
+inline void XML_Decl_Parser::Advance(int n) {
+	buffer_rel_pos += n;
+}
+
+inline void XML_Decl_Parser::Scan_WS() {
+	while (at_WhiteSpace_10<ASCII>(cur())) Advance(1);
+}
+
+inline void XML_Decl_Parser::ScanToQuote() {
+	while (!AtQuote<ASCII>(cur())) buffer_rel_pos+=1;
+}
+
+inline void XML_Decl_Parser::ParseVersion(Entity_Info & e) {
+	/* Skip "version" */
+	Advance(7);
+	Scan_WS();
+	if (!AtChar<ASCII,'='>(cur())) DeclError();
+	Advance(1);
+	Scan_WS();
+	if (at_1_0<ASCII>(cur())) e.version = XML_1_0;
+	else if (at_1_1<ASCII>(cur())) e.version = XML_1_1;
+	else DeclError();
+	Advance(5);
+}
+
+inline void XML_Decl_Parser::ParseEncoding(Entity_Info & e) {
+	/* Skip "encoding" */
+	Advance(8);
+	e.has_encoding_decl = true;
+	Scan_WS();
+	if (!AtChar<ASCII,'='>(cur())) DeclError();
+	Advance(1);
+	Scan_WS();
+	if (AtQuote<ASCII>(cur())) {
+		unsigned char quoteCh = cur()[0];
+		Advance(1);
+		int start_pos = AbsPos();
+		ScanToQuote();
+		if (cur()[0] != quoteCh) DeclError();
+		int lgth = AbsPos() - start_pos;
+		e.encoding = new unsigned char[lgth + 1];
+		memcpy(e.encoding, &x8data[start_pos-buffer_base_pos], lgth);
+		e.encoding[lgth] = '\0';
+	}
+	else DeclError();
+	Advance(1);
+}
+
+inline void XML_Decl_Parser::ParseStandalone(Entity_Info & e) {
+	/* Skip "standalone" */
+	Advance(10);
+	Scan_WS();
+	if (!AtChar<ASCII,'='>(cur())) DeclError();
+	Advance(1);
+	Scan_WS();
+	if (at_yes<ASCII>(cur())) {Advance(5); e.standalone = Standalone_yes;}
+	else if (at_no<ASCII>(cur())) {Advance(4); e.standalone = Standalone_no;}
+	else DeclError();
+}
+
+void XML_Decl_Parser::ReadXMLInfo(Entity_Info & e) {
+	e.version = no_XML_version_value;
+	e.has_encoding_decl = false;
+	e.standalone = Standalone_no_value;
+	buffer_rel_pos = e.BOM_units;
+	// It is possible that there is no XML declaration.
+	if (!at_XmlDecl_start<ASCII>(cur())) {
+		e.content_start = AbsPos();
+		return;
+	}
+	// Otherwise, the XML declaration exists and must have
+	// at least version information.
+	Advance(6);
+	Scan_WS();
+	if (!at_version<ASCII>(cur())) DeclError();
+	ParseVersion(e);
+	if (at_PI_End<ASCII>(cur())) {
+		e.content_start = AbsPos()+2;
+		return;
+	}
+	if (!at_WhiteSpace_10<ASCII>(cur())) DeclError();
+	Scan_WS();
+	if (at_encoding<ASCII>(cur())) {
+		ParseEncoding(e);
+		if (at_PI_End<ASCII>(cur())) {
+			e.content_start = AbsPos()+2;
+			return;
+		}
+		if (!at_WhiteSpace_10<ASCII>(cur())) DeclError();
+		Scan_WS();
+	}
+	if (at_standalone<ASCII>(cur())) {
+		ParseStandalone(e);
+		Scan_WS();
+	}
+	if (!at_PI_End<ASCII>(cur())) DeclError();
+	e.content_start = AbsPos()+2;
+}
+
+// Similar to reading the XML_declaration of the document entity,
+// ReadTextDeclaration reads the text declaration of an external
+// parsed entity.
+
+void XML_Decl_Parser::ReadTextDeclaration(Entity_Info & e) {
+	e.version = no_XML_version_value;
+	e.has_encoding_decl = false;
+	e.standalone = Standalone_no_value;
+	buffer_rel_pos = e.BOM_units;
+	// It is possible that there is no text declaration.
+	if (!at_XmlDecl_start<ASCII>(cur())) {
+		e.content_start = AbsPos();
+		return;
+	}
+	// Otherwise, the text declaration exists and may have
+	// version information.
+	Advance(6);
+	Scan_WS();
+	if (at_version<ASCII>(cur())) {
+		ParseVersion(e);
+		// Must have whitespace character before encoding declaration.
+		if (!at_WhiteSpace_10<ASCII>(cur())) DeclError();
+		Scan_WS();
+	}
+	if (!at_encoding<ASCII>(cur())) DeclError();
+	ParseEncoding(e);
+	Scan_WS();
+	if (!at_PI_End<ASCII>(cur())) DeclError();
+	e.content_start = AbsPos()+2;
+}
+
+void XML_Decl_Parser::ReadXMLorTextDecl(Entity_Info & e) {
+	e.version = no_XML_version_value;
+	e.has_encoding_decl = false;
+	e.standalone = Standalone_no_value;
+	buffer_rel_pos = e.BOM_units;
+	// It is possible that there is no XML or text declaration.
+	if (!at_XmlDecl_start<ASCII>(cur())) {
+		e.content_start = AbsPos();
+		return;
+	}
+	// Otherwise, the XML or text declaration exists and may have
+	// version information.
+	Advance(6);
+	Scan_WS();
+	if (at_version<ASCII>(cur())) {
+		ParseVersion(e);
+		if (at_PI_End<ASCII>(cur())) {
+			e.content_start = AbsPos()+2;
+			return;
+		}
+		if (!at_WhiteSpace_10<ASCII>(cur())) DeclError();
+		Scan_WS();
+		if (at_encoding<ASCII>(cur())) {
+			ParseEncoding(e);
+			if (at_PI_End<ASCII>(cur())) {
+				e.content_start = AbsPos()+2;
+				return;
+			}
+			if (!at_WhiteSpace_10<ASCII>(cur())) DeclError();
+			Scan_WS();
+		}
+		if (at_standalone<ASCII>(cur())) {
+			ParseStandalone(e);
+			Scan_WS();
+		}
+	}
+	else {	// Without version, we can only have a text declaration,
+		// in which case an encoding spec is required.
+		if (!at_encoding<ASCII>(cur())) DeclError();
+		ParseEncoding(e);
+		Scan_WS();
+		// No standalone spec is allowed in a text declaration.
+	}
+	if (!at_PI_End<ASCII>(cur())) DeclError();	
+	e.content_start = AbsPos()+2;
+}