react-native-quick-crypto 1.0.19 → 1.1.0

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

@@ -0,0 +1,239 @@
+/*  multiliteral.h - XML Multicharacter Recognizers.
+    Copyright (c) 2007, 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.
+
+This file provides a library of routines for the efficient recognition 
+of particular XML multicharacter sequences.  Sequences of length 2 are 
+compared as 16 bit integers, sequences of length 3 or 4 are compared 
+as 32 bit integers and other sequences of length up to 8 are compared as
+64 bit integers.  The integer value for each XML multicharacter sequence
+is determined as a compile-time constant for optimal efficiency.
+
+All functions are declared inline; there is no corresponding multiliteral.c
+file required.   */
+
+#ifndef MULTILITERAL_H
+#define MULTILITERAL_H
+
+#include <assert.h>
+#include <stdint.h>
+#include "xmldecl.h"
+#include "charsets/ASCII_EBCDIC.h"
+
+#if BYTE_ORDER == BIG_ENDIAN
+const int LOW_BYTE_SHIFT = 8;
+const int HIGH_BYTE_SHIFT = 0;
+#endif
+#if BYTE_ORDER == LITTLE_ENDIAN
+const int LOW_BYTE_SHIFT = 0;
+const int HIGH_BYTE_SHIFT = 8;
+#endif
+
+/*
+Helper metafunctions.  Given 2, 4 or 8 characters comprising a sequence, 
+the c2int16, c4int32, and c8int64 functions determine the corresponding 
+16, 32 or 64 bit integer value.   These are template metafunctions that
+must be instantiated with constant arguments to be applied at compile time.
+The functions may be instantiated for ASCII or EBCDIC based byte
+sequences.
+For example, c2int16<ASCII, '<', '/'>::value produces the compile
+time constant for the 16-bit value of an ASCII-based byte sequence
+of the XML end tag opening delimiter.
+*/
+
+template <unsigned char byte1, unsigned char byte2>
+struct b2int16 {
+  static uint16_t const value =
+    (((uint16_t) byte1) << LOW_BYTE_SHIFT) +
+    (((uint16_t) byte2) << HIGH_BYTE_SHIFT);
+};
+
+template <CodeUnit_Base C, unsigned char c1, unsigned char c2>
+struct c2int16 {
+  static uint16_t const value = b2int16<Ord<C,c1>::value, Ord<C,c2>::value>::value;
+};
+
+template <CodeUnit_Base C, unsigned char c1, unsigned char c2,
+                      unsigned char c3, unsigned char c4>
+struct c4int32 {
+  static uint32_t const value =
+    (((uint32_t) c2int16<C,c1,c2>::value) << (2 * LOW_BYTE_SHIFT)) + 
+    (((uint32_t) c2int16<C,c3,c4>::value) << (2 * HIGH_BYTE_SHIFT));
+};
+
+template <CodeUnit_Base C, unsigned char c1, unsigned char c2,
+                      unsigned char c3, unsigned char c4,
+                      unsigned char c5, unsigned char c6,
+                      unsigned char c7, unsigned char c8>
+struct c8int64 {
+  static uint64_t const value =
+    (((uint64_t) c4int32<C, c1, c2, c3, c4>::value) << (4 * LOW_BYTE_SHIFT)) + 
+    (((uint64_t) c4int32<C, c5, c6, c7, c8>::value) << (4 * HIGH_BYTE_SHIFT));
+};
+
+
+/*  Specialized helpers for 3, 5, 6, and 7 character combinations. */
+
+template <CodeUnit_Base C, unsigned char c1, unsigned char c2,
+                      unsigned char c3>
+struct c3int32 {
+  static uint32_t const value = c4int32<C, c1, c2, c3, 0>::value;
+};
+
+template <CodeUnit_Base C, unsigned char c1, unsigned char c2,
+                      unsigned char c3, unsigned char c4,
+                      unsigned char c5>
+struct c5int64 {
+  static uint64_t const value = c8int64<C, c1, c2, c3, c4, c5, 0, 0, 0>::value;
+};
+
+template <CodeUnit_Base C, unsigned char c1, unsigned char c2,
+                      unsigned char c3, unsigned char c4,
+                      unsigned char c5, unsigned char c6>
+struct c6int64 {
+  static uint64_t const value = c8int64<C, c1, c2, c3, c4, c5, c6, 0, 0>::value;
+};
+
+template <CodeUnit_Base C, unsigned char c1, unsigned char c2,
+                      unsigned char c3, unsigned char c4,
+                      unsigned char c5, unsigned char c6,
+                      unsigned char c7>
+struct c7int64 {
+  static uint64_t const value = c8int64<C, c1, c2, c3, c4, c5, c6, c7, 0>::value;
+};
+
+
+/* 
+A second set of helper functions determines 16, 32, or 64 bit integer
+values from character arrays.
+Precondition:  the character array is allocated with at least the
+number of required characters in each case. */
+static inline uint16_t s2int16(unsigned char s[]) {
+  return * ((uint16_t *) s);
+}
+
+static inline uint32_t s4int32(unsigned char s[]) {
+  return * ((uint32_t *) s);
+}
+
+static inline uint64_t s8int64(unsigned char s[]) {
+  return * ((uint64_t *) s);
+}
+
+static inline uint32_t s3int32(unsigned char s[]) {
+  return s4int32(s) & (0xFFFFFF << LOW_BYTE_SHIFT);
+}
+
+static inline uint64_t s5int64(unsigned char s[]) {
+  return s8int64(s) & (0xFFFFFFFFFFULL << (3 * LOW_BYTE_SHIFT));
+}
+
+static inline uint64_t s6int64(unsigned char s[]) {
+  return s8int64(s) & (0xFFFFFFFFFFFFULL << (2 * LOW_BYTE_SHIFT));
+}
+
+static inline uint64_t s7int64(unsigned char s[]) {
+  return s8int64(s) & (0xFFFFFFFFFFFFFFULL << LOW_BYTE_SHIFT);
+}
+
+template <CodeUnit_Base C, unsigned char c1, unsigned char c2>
+static inline bool caseless_comp(unsigned char s[]) {
+  const uint16_t lc = c2int16<C, UC2lc<c1>::value, UC2lc<c2>::value>::value;
+  const uint16_t UC = c2int16<C, lc2UC<c1>::value, lc2UC<c2>::value>::value;
+  const uint16_t case_mask = lc ^ UC;
+  const uint16_t canon = lc & ~case_mask;
+  return (s2int16(s) & ~case_mask) == canon;
+}
+
+template <CodeUnit_Base C, unsigned char c1, unsigned char c2, unsigned char c3>
+static inline bool caseless_comp(unsigned char s[]) {
+  const uint32_t lc = c3int32<C, UC2lc<c1>::value, UC2lc<c2>::value, UC2lc<c3>::value>::value;
+  const uint32_t UC = c3int32<C, lc2UC<c1>::value, lc2UC<c2>::value, lc2UC<c3>::value>::value;
+  const uint32_t case_mask = lc ^ UC;
+  const uint32_t canon = lc & ~case_mask;
+  return (s3int32(s) & ~case_mask) == canon;
+}
+
+template <CodeUnit_Base C, unsigned char c1, unsigned char c2, 
+			   unsigned char c3, unsigned char c4>
+static inline bool caseless_comp(unsigned char s[]) {
+  const uint32_t lc = c4int32<C, UC2lc<c1>::value, UC2lc<c2>::value,
+                                 UC2lc<c3>::value, UC2lc<c4>::value>::value;
+  const uint32_t UC = c4int32<C, lc2UC<c1>::value, lc2UC<c2>::value, 
+                                 lc2UC<c3>::value, lc2UC<c4>::value>::value; 
+  const uint32_t case_mask = lc ^ UC;
+  const uint32_t canon = lc & ~case_mask;
+  return (s4int32(s) & ~case_mask) == canon;
+}
+
+template <CodeUnit_Base C, unsigned char c1, unsigned char c2, 
+			   unsigned char c3, unsigned char c4,
+			   unsigned char c5>
+static inline bool caseless_comp(unsigned char s[]) {
+  const uint64_t lc = c5int64<C, UC2lc<c1>::value, UC2lc<c2>::value,
+                                 UC2lc<c3>::value, UC2lc<c4>::value,
+				 UC2lc<c5>::value>::value;
+  const uint64_t UC = c5int64<C, lc2UC<c1>::value, lc2UC<c2>::value, 
+                                 lc2UC<c3>::value, lc2UC<c4>::value, 
+				 lc2UC<c5>::value>::value; 
+  const uint64_t case_mask = lc ^ UC;
+  const uint64_t canon = lc & ~case_mask;
+  return (s5int64(s) & ~case_mask) == canon;
+}
+
+template <CodeUnit_Base C, unsigned char c1, unsigned char c2, 
+			   unsigned char c3, unsigned char c4,
+			   unsigned char c5, unsigned char c6>
+static inline bool caseless_comp(unsigned char s[]) {
+  const uint64_t lc = c6int64<C, UC2lc<c1>::value, UC2lc<c2>::value,
+                                 UC2lc<c3>::value, UC2lc<c4>::value,
+				 UC2lc<c5>::value, UC2lc<c6>::value>::value;
+  const uint64_t UC = c6int64<C, lc2UC<c1>::value, lc2UC<c2>::value, 
+                                 lc2UC<c3>::value, lc2UC<c4>::value, 
+				 lc2UC<c5>::value, lc2UC<c6>::value>::value; 
+  const uint64_t case_mask = lc ^ UC;
+  const uint64_t canon = lc & ~case_mask;
+  return (s6int64(s) & ~case_mask) == canon;
+}
+
+template <CodeUnit_Base C, unsigned char c1, unsigned char c2, 
+			   unsigned char c3, unsigned char c4,
+			   unsigned char c5, unsigned char c6,
+			   unsigned char c7>
+static inline bool caseless_comp(unsigned char s[]) {
+  const uint64_t lc = c7int64<C, UC2lc<c1>::value, UC2lc<c2>::value,
+                                 UC2lc<c3>::value, UC2lc<c4>::value,
+				 UC2lc<c5>::value, UC2lc<c6>::value,
+				 UC2lc<c7>::value>::value;
+  const uint64_t UC = c7int64<C, lc2UC<c1>::value, lc2UC<c2>::value, 
+                                 lc2UC<c3>::value, lc2UC<c4>::value, 
+				 lc2UC<c5>::value, lc2UC<c6>::value, 
+				 lc2UC<c7>::value>::value; 
+  const uint64_t case_mask = lc ^ UC;
+  const uint64_t canon = lc & ~case_mask;
+  return (s7int64(s) & ~case_mask) == canon;
+}
+
+template <CodeUnit_Base C, unsigned char c1, unsigned char c2, 
+			   unsigned char c3, unsigned char c4,
+			   unsigned char c5, unsigned char c6,
+			   unsigned char c7, unsigned char c8>
+static inline bool caseless_comp(unsigned char s[]) {
+  const uint64_t lc = c8int64<C, UC2lc<c1>::value, UC2lc<c2>::value,
+                                 UC2lc<c3>::value, UC2lc<c4>::value,
+				 UC2lc<c5>::value, UC2lc<c6>::value,
+				 UC2lc<c7>::value, UC2lc<c8>::value>::value;
+  const uint64_t UC = c8int64<C, lc2UC<c1>::value, lc2UC<c2>::value, 
+                                 lc2UC<c3>::value, lc2UC<c4>::value, 
+				 lc2UC<c5>::value, lc2UC<c6>::value, 
+				 lc2UC<c7>::value, lc2UC<c8>::value>::value; 
+  const uint64_t case_mask = lc ^ UC;
+  const uint64_t canon = lc & ~case_mask;
+  return (s8int64(s) & ~case_mask) == canon;
+}
+
+
+
+#endif

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

@@ -0,0 +1,232 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <stdint.h>
+#ifndef UNICODE_CONVERT
+#ifndef _MSC_VER
+#include <iconv.h>
+#endif
+#endif
+
+#ifdef _MSC_VER
+//#undef BUFFER_PROFILING
+#undef STD_ICONV
+#endif
+// Profiling
+
+#ifdef BUFFER_PROFILING
+#include "../Profiling/BOM_Profiler.h"
+BOM_Table * transcode_timer;
+#endif
+
+/* Counting the number of blocks classified by the
+   maxiumum UTF-8 sequence length within the block. */
+#ifdef BLOCK_COUNTING
+int block_counts[4] = {0,0,0,0};
+#endif
+
+#define BUFFER_SIZE 2048
+#define U16BUFFER_UNITS (BUFFER_SIZE + 16)
+
+#ifdef UNICODE_ORG_CONVERT
+#undef STD_ICONV
+#undef FAST_U8U16
+#define error_in_result(rslt) rslt != conversionOK
+#define illegal_sequence_error(rslt) rslt == sourceIllegal
+#define incomplete_sequence_error(rslt) rslt == sourceExhausted
+#endif
+
+#ifndef UNICODE_ORG_CONVERT
+#define error_in_result(rslt) rslt == (size_t) -1
+#define illegal_sequence_error(rslt) u8u16_errno == EILSEQ
+#define incomplete_sequence_error(rslt) u8u16_errno == EINVAL
+
+
+#ifdef STD_ICONV
+#undef FAST_U8U16
+#endif
+#ifndef STD_ICONV
+#define FAST_U8U16 1
+#endif
+#endif
+
+// Include the conversion routines.
+#ifdef UNICODE_ORG_CONVERT
+//#include "Unicode.org/ConvertUTF.h"
+#include "Unicode.org/ConvertUTF.c"
+#endif
+#ifdef FAST_U8U16
+#include "libu8u16.c"
+#endif
+
+
+void do_UTF8toUTF16(FILE *infile, FILE *outfile) {
+
+#ifdef __GNUC__
+  unsigned char UTF8_buffer[BUFFER_SIZE] __attribute__((aligned(16)));
+#endif
+#ifdef _MSC_VER
+  __declspec(align(16)) unsigned char UTF8_buffer[BUFFER_SIZE];
+#endif
+  unsigned short UTF16_buffer[U16BUFFER_UNITS];
+  unsigned char * srcbuf_ptr = &UTF8_buffer[0];
+  unsigned short * trgtbuf_ptr = &UTF16_buffer[0];
+  size_t inbytes_left, outbytes_left;
+  int file_position = 0;
+
+  intptr_t chars_read, i, UTF16_chars;
+  int u8u16_errno;
+    
+#ifdef UNICODE_ORG_CONVERT
+   ConversionResult rslt;
+#endif
+#ifdef STD_ICONV
+   iconv_t cd = iconv_open("UTF-16BE", "UTF-8");
+   size_t rslt;
+#endif
+#ifdef FAST_U8U16
+   size_t rslt;
+#endif
+
+  chars_read = fread(&UTF8_buffer, 1, BUFFER_SIZE, infile);
+
+  while (chars_read > 0) {
+#ifdef BUFFER_PROFILING
+    start_BOM_interval(transcode_timer);
+#endif 
+    srcbuf_ptr = &UTF8_buffer[0];
+    trgtbuf_ptr = &UTF16_buffer[0];
+    inbytes_left = chars_read;
+    outbytes_left = U16BUFFER_UNITS*2;
+#ifdef STD_ICONV
+    rslt = iconv(cd,
+                 (char **) &srcbuf_ptr, 
+                 &inbytes_left,
+                 (char **) &trgtbuf_ptr, 
+                 &outbytes_left);
+    u8u16_errno = errno;
+#endif
+#ifdef UNICODE_ORG_CONVERT
+    rslt = ConvertUTF8toUTF16((const UTF8**) &srcbuf_ptr, 
+                              srcbuf_ptr + chars_read,
+                              &trgtbuf_ptr, 
+                              &UTF16_buffer[BUFFER_SIZE],
+                              strictConversion);
+    inbytes_left = chars_read - (srcbuf_ptr - &UTF8_buffer[0]);
+#endif
+#ifdef FAST_U8U16
+#ifndef BUFFERED_U8U16
+    rslt = u8u16((char **) &srcbuf_ptr, 
+                 &inbytes_left,
+                 (char **) &trgtbuf_ptr, 
+                 &outbytes_left);
+#endif
+#ifdef BUFFERED_U8U16
+    rslt = buffered_u8u16((char **) &srcbuf_ptr, 
+                 &inbytes_left,
+                 (char **) &trgtbuf_ptr, 
+                 &outbytes_left);
+#endif
+    u8u16_errno = errno;
+#endif
+
+#ifdef BUFFER_PROFILING
+     end_BOM_interval(transcode_timer, chars_read - inbytes_left);
+#endif 
+    file_position += chars_read - inbytes_left;
+    UTF16_chars = ((intptr_t) trgtbuf_ptr - (intptr_t) &UTF16_buffer[0])/2;
+    fwrite(&UTF16_buffer, 2, UTF16_chars, outfile);
+    if (error_in_result(rslt)) {
+      if (illegal_sequence_error(rslt)) {
+        int pos = 0;
+        fprintf(stderr, "Illegal UTF-8 sequence at position %i in source.\n", file_position);
+#ifdef DEBUG_ERROR
+        for (pos =0; (pos < 5) && (pos < inbytes_left); pos++) {
+          fprintf(stderr, " %02X", (unsigned char) srcbuf_ptr[pos]);
+        }
+        fprintf(stderr, "\n");
+#endif
+        fclose(infile);
+        fclose(outfile);
+        exit(-1);
+      }
+      if (!incomplete_sequence_error(rslt)) {
+        fprintf(stderr, "Unknown error %i at position %i in source.\n", errno, file_position);
+        fclose(infile);
+        fclose(outfile);
+        exit(-1);
+      }
+      // errno == EINVAL  or rslt == sourceExhausted
+      // Incomplete sequence at end of input buffer. 
+      if (chars_read < BUFFER_SIZE) {
+        int pos = 0;
+        fprintf(stderr, "EOF with incomplete UTF-8 sequence at position %i in source.\n", file_position);
+#ifdef DEBUG_ERROR
+        for (pos =0; (pos < 5) && (pos < inbytes_left); pos++) {
+          fprintf(stderr, " %02X", (unsigned char) srcbuf_ptr[pos]);
+        }
+        fprintf(stderr, "\n");
+#endif
+        fclose(infile);
+        fclose(outfile);
+        exit(-1);
+      }
+      // Move unprocessed characters to beginning.
+      for (i = 0; i < inbytes_left; i++) {
+        UTF8_buffer[i] = UTF8_buffer[chars_read - inbytes_left + i];
+      }
+
+    }
+    chars_read = fread(&UTF8_buffer[inbytes_left], 1, BUFFER_SIZE-inbytes_left, infile);
+    chars_read += inbytes_left;
+  }
+#ifdef STD_ICONV
+  iconv_close(cd);
+#endif
+  fclose(infile);
+  fclose(outfile);
+}
+
+
+
+
+int
+main(int argc, char * argv[]) {
+  if (argc < 2) {
+    printf("Usage: %s <filename.u8> [<filename.u16>].\n", argv[0]);
+	  exit(-1);
+  }
+  char * filename = argv[1];
+#ifdef BUFFER_PROFILING
+  transcode_timer = init_BOM_timer();
+#endif 
+  FILE *infile, *outfile;
+  infile = fopen(filename, "rb");
+  if (!infile) {
+      fprintf(stderr, "Error: cannot open %s for input.\n", filename);
+      exit(-1);
+  }
+
+  if (argc < 3) outfile = stdout;
+  else {
+    outfile = fopen(argv[2], "wb");
+    if (!outfile) {
+      fprintf(stderr, "Error: cannot open %s for writing.\n", argv[2]);
+      exit(-1);
+    }
+  }
+
+  do_UTF8toUTF16(infile, outfile);
+
+#ifdef BUFFER_PROFILING
+  printf("Buffer conversion timing.\n");
+  dump_BOM_table(transcode_timer);
+#endif
+#ifdef BLOCK_COUNTING
+printf("%i bytes in pure ASCII blocks.\n", block_counts[0]);
+printf("%i bytes in blocks confined to two-byte subplane.\n", block_counts[1]);
+printf("%i bytes in blocks confined to basic multilingual plane.\n", block_counts[2]);
+printf("%i bytes in blocks containing 4-byte UTF-8 sequences.\n", block_counts[3]);
+#endif
+  return(0);
+}

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

@@ -0,0 +1,194 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <stdint.h>
+#ifndef _MSC_VER
+#include <iconv.h>
+#endif
+
+
+#include "xmldecl.h"
+
+// Profiling	
+
+#ifdef BUFFER_PROFILING
+#include "../Profiling/BOM_Profiler.h"
+BOM_Table * transcode_timer;
+#endif
+
+
+#define BUFFER_SIZE 2048
+
+#define error_in_result(rslt) rslt == (size_t) -1
+#define illegal_sequence_error(rslt) errno == EILSEQ
+#define incomplete_sequence_error(rslt) errno == EINVAL
+
+
+#define FAST_U8U16 1
+
+// Include the conversion routines.
+#include "libu8u16.c"
+
+#include "xml_error.c"
+#include "xmldecl.c"
+
+unsigned char xml_decl_u16[12] = 
+     {'\0', '<', '\0', '?', '\0', 'x', '\0', 'm', '\0', 'l', '\0', ' '};
+unsigned char version[28] = 
+     {'\0', 'v', '\0', 'e', '\0', 'r', '\0', 's', '\0', 'i', '\0', 'o', '\0', 'n', 
+      '\0', '=', '\0', '"', '\0', '1', '\0', '.', '\0', '0', '\0', '"', '\0', ' '};
+unsigned char encoding[34] = 
+     {'\0', 'e', '\0', 'n', '\0', 'c', '\0', 'o', '\0', 'd',
+      '\0', 'i', '\0', 'n', '\0', 'g', '\0', '=', '\0', '"', 
+      '\0', 'u', '\0', 't', '\0', 'f', '\0', '-', '\0', '1', '\0', '6', '\0', '"'};
+unsigned char standalone[34] = 
+     {'\0', ' ', '\0', 's', '\0', 't', '\0', 'a', '\0', 'n',
+      '\0', 'd', '\0', 'a', '\0', 'l', '\0', 'o', '\0', 'n', 
+      '\0', 'e', '\0', '=', '\0', '"', '\0', 'y', '\0', 'e', '\0', 's', '\0', '"'};
+unsigned char xml_decl_end[4] = {'\0', '?', '\0', '>'};
+
+
+
+void do_UTF8toUTF16(FILE *infile, FILE *outfile) {
+
+#ifdef __GNUC__
+  unsigned char UTF8_buffer[BUFFER_SIZE] __attribute__((aligned(16)));
+#endif
+#ifdef _MSC_VER
+  __declspec(align(16)) unsigned char UTF8_buffer[BUFFER_SIZE];
+#endif
+  unsigned short UTF16_buffer[BUFFER_SIZE];
+  unsigned char * srcbuf_ptr = &UTF8_buffer[0];
+  unsigned short * trgtbuf_ptr = &UTF16_buffer[0];
+  size_t inbytes_left, outbytes_left;
+  int file_position = 0;
+
+  intptr_t chars_read, i, UTF16_chars;
+    
+   size_t rslt;
+
+  chars_read = fread(&UTF8_buffer, 1, BUFFER_SIZE, infile);
+
+  if (chars_read < 4) {
+	fprintf(stderr, "Input document empty or too short\n");
+	exit(-1);
+  }
+
+  Entity_Info * e = new Entity_Info;
+  e->AnalyzeSignature(UTF8_buffer);
+  XML_Decl_Parser decl_parser((unsigned char *)&UTF8_buffer);
+
+  decl_parser.ReadXMLorTextDecl(*e);
+
+  if (e->content_start != 0) {
+	memmove(&UTF8_buffer[0], &UTF8_buffer[e->content_start], chars_read - e->content_start);
+	if (chars_read == BUFFER_SIZE) {
+		chars_read = BUFFER_SIZE - e->content_start + 
+                             fread(&UTF8_buffer[BUFFER_SIZE-e->content_start], 1, e->content_start, infile);
+	}
+  }
+  /* Write UTF-16 BOM */
+  fputc(0xFE, outfile);
+  fputc(0xFF, outfile);
+
+  if (e->content_start > e->BOM_units) {
+	// Duplicate original XML/text declaration with encoding="UTF-16"
+	fwrite(&xml_decl_u16[0], 1, 12, outfile);
+	if (e->version == XML_1_0)
+		fwrite(&version[0], 1, 28, outfile);
+	else if (e->version == XML_1_0) {
+		fwrite(&version[0], 1, 23, outfile);
+		fputc('1', outfile);
+		fwrite(&version[24], 1, 4, outfile);
+	}
+	fwrite(&encoding[0], 1, 34, outfile);
+	if (e->standalone == Standalone_yes)
+		fwrite(&standalone[0], 1, 34, outfile);
+	else if (e->standalone == Standalone_no) {
+		fwrite(&standalone[0], 1, 27, outfile);
+		fputc('n', outfile);
+		fputc('\0', outfile);
+		fputc('o', outfile);
+		fwrite(&standalone[32], 1, 2, outfile);
+	}
+	fwrite(&xml_decl_end[0], 1, 4, outfile);
+  }
+  while (chars_read > 0) {
+    srcbuf_ptr = &UTF8_buffer[0];
+    trgtbuf_ptr = &UTF16_buffer[0];
+    inbytes_left = chars_read;
+    outbytes_left = BUFFER_SIZE*2;
+   rslt = u8u16((char **) &srcbuf_ptr, 
+                 &inbytes_left,
+                 (char **) &trgtbuf_ptr, 
+                 &outbytes_left);
+
+    file_position += chars_read - inbytes_left;
+    UTF16_chars = ((intptr_t) trgtbuf_ptr - (intptr_t) &UTF16_buffer[0])/2;
+    fwrite(&UTF16_buffer, 2, UTF16_chars, outfile);
+    if (error_in_result(rslt)) {
+      if (illegal_sequence_error(rslt)) {
+        int pos = 0;
+        fprintf(stderr, "Illegal UTF-8 sequence at position %i in source.\n", file_position);
+        fclose(infile);
+        fclose(outfile);
+        exit(-1);
+      }
+      if (!incomplete_sequence_error(rslt)) {
+        fprintf(stderr, "Unknown error %i at position %i in source.\n", errno, file_position);
+        fclose(infile);
+        fclose(outfile);
+        exit(-1);
+      }
+      // errno == EINVAL  or rslt == sourceExhausted
+      // Incomplete sequence at end of input buffer. 
+      if (chars_read < BUFFER_SIZE) {
+        int pos = 0;
+        fprintf(stderr, "EOF with incomplete UTF-8 sequence at position %i in source.\n", file_position);
+       fclose(infile);
+        fclose(outfile);
+        exit(-1);
+      }
+      // Move unprocessed characters to beginning.
+      for (i = 0; i < inbytes_left; i++) {
+        UTF8_buffer[i] = UTF8_buffer[chars_read - inbytes_left + i];
+      }
+
+    }
+    chars_read = fread(&UTF8_buffer[inbytes_left], 1, BUFFER_SIZE-inbytes_left, infile);
+    chars_read += inbytes_left;
+  }
+  fclose(infile);
+  fclose(outfile);
+}
+
+
+
+
+int
+main(int argc, char * argv[]) {
+  if (argc < 2) {
+    printf("Usage: %s <filename> [<filename.u16>].\n", argv[0]);
+	  exit(-1);
+  }
+  char * filename = argv[1];
+  FILE *infile, *outfile;
+  infile = fopen(filename, "rb");
+  if (!infile) {
+      fprintf(stderr, "Error: cannot open %s for input.\n", filename);
+      exit(-1);
+  }
+
+  if (argc < 3) outfile = stdout;
+  else {
+    outfile = fopen(argv[2], "wb");
+    if (!outfile) {
+      fprintf(stderr, "Error: cannot open %s for writing.\n", argv[2]);
+      exit(-1);
+    }
+  }
+
+  do_UTF8toUTF16(infile, outfile);
+
+  return(0);
+}