Source: main/webapp/modules/UTF8Parser.js

  1. /*
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *   http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing,
  13.  * software distributed under the License is distributed on an
  14.  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  15.  * KIND, either express or implied.  See the License for the
  16.  * specific language governing permissions and limitations
  17.  * under the License.
  18.  */
  20. var Guacamole = Guacamole || {};
  22. /**
  23.  * Parser that decodes UTF-8 text from a series of provided ArrayBuffers.
  24.  * Multi-byte characters that continue from one buffer to the next are handled
  25.  * correctly.
  26.  *
  27.  * @constructor
  28.  */
  29. Guacamole.UTF8Parser = function UTF8Parser() {
  31.     /**
  32.      * The number of bytes remaining for the current codepoint.
  33.      *
  34.      * @private
  35.      * @type {!number}
  36.      */
  37.     var bytesRemaining = 0;
  39.     /**
  40.      * The current codepoint value, as calculated from bytes read so far.
  41.      *
  42.      * @private
  43.      * @type {!number}
  44.      */
  45.     var codepoint = 0;
  47.     /**
  48.      * Decodes the given UTF-8 data into a Unicode string, returning a string
  49.      * containing all complete UTF-8 characters within the provided data. The
  50.      * data may end in the middle of a multi-byte character, in which case the
  51.      * complete character will be returned from a later call to decode() after
  52.      * enough bytes have been provided.
  53.      *
  54.      * @private
  55.      * @param {!ArrayBuffer} buffer
  56.      *     Arbitrary UTF-8 data.
  57.      *
  58.      * @return {!string}
  59.      *     The decoded Unicode string.
  60.      */
  61.     this.decode = function decode(buffer) {
  63.         var text = '';
  65.         var bytes = new Uint8Array(buffer);
  66.         for (var i=0; i<bytes.length; i++) {
  68.             // Get current byte
  69.             var value = bytes[i];
  71.             // Start new codepoint if nothing yet read
  72.             if (bytesRemaining === 0) {
  74.                 // 1 byte (0xxxxxxx)
  75.                 if ((value | 0x7F) === 0x7F)
  76.                     text += String.fromCharCode(value);
  78.                 // 2 byte (110xxxxx)
  79.                 else if ((value | 0x1F) === 0xDF) {
  80.                     codepoint = value & 0x1F;
  81.                     bytesRemaining = 1;
  82.                 }
  84.                 // 3 byte (1110xxxx)
  85.                 else if ((value | 0x0F )=== 0xEF) {
  86.                     codepoint = value & 0x0F;
  87.                     bytesRemaining = 2;
  88.                 }
  90.                 // 4 byte (11110xxx)
  91.                 else if ((value | 0x07) === 0xF7) {
  92.                     codepoint = value & 0x07;
  93.                     bytesRemaining = 3;
  94.                 }
  96.                 // Invalid byte
  97.                 else
  98.                     text += '\uFFFD';
  100.             }
  102.             // Continue existing codepoint (10xxxxxx)
  103.             else if ((value | 0x3F) === 0xBF) {
  105.                 codepoint = (codepoint << 6) | (value & 0x3F);
  106.                 bytesRemaining--;
  108.                 // Write codepoint if finished
  109.                 if (bytesRemaining === 0)
  110.                     text += String.fromCharCode(codepoint);
  112.             }
  114.             // Invalid byte
  115.             else {
  116.                 bytesRemaining = 0;
  117.                 text += '\uFFFD';
  118.             }
  120.         }
  122.         return text;
  124.     };
  126. };