react-native-quick-crypto 1.1.0 → 1.1.1

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

@@ -1,239 +0,0 @@
-/*  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

@@ -1,232 +0,0 @@
-#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

@@ -1,194 +0,0 @@
-#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);
-}