FilesExpand file tree

 pointer_bindings

/

string_decoder.js

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

91 lines (72 loc) · 2.53 KB

 pointer_bindings

/

string_decoder.js

Copy path

Top

File metadata and controls

• Code
• Blame

91 lines (72 loc) · 2.53 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

var StringDecoder = exports.StringDecoder = function(encoding) {

this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');

if (this.encoding === 'utf8') {

this.charBuffer = new Buffer(4);

this.charReceived = 0;

this.charLength = 0;

}

};

StringDecoder.prototype.write = function(buffer) {

// If not utf8...

if (this.encoding !== 'utf8') {

return buffer.toString(this.encoding);

}

var charStr = '';

// if our last write ended with an incomplete multibyte character

if (this.charLength) {

// determine how many remaining bytes this buffer has to offer for this char

var i = (buffer.length >= this.charLength - this.charReceived) ?

this.charLength - this.charReceived :

buffer.length;

// add the new bytes to the char buffer

buffer.copy(this.charBuffer, this.charReceived, 0, i);

this.charReceived += i;

if (this.charReceived < this.charLength) {

// still not enough chars in this buffer? wait for more ...

return '';

}

// get the character that was split

charStr = this.charBuffer.slice(0, this.charLength).toString();

this.charReceived = this.charLength = 0;

// if there are no more bytes in this buffer, just emit our char

if (i == buffer.length) return charStr;

// otherwise cut off the characters end from the beginning of this buffer

buffer = buffer.slice(i, buffer.length);

}

// determine how many bytes we have to check at the end of this buffer

var i = (buffer.length >= 3) ? 3 : buffer.length;

// Figure out if one of the last i bytes of our buffer announces an

// incomplete char.

for (; i > 0; i--) {

var c = buffer[buffer.length - i];

// See http://en.wikipedia.org/wiki/UTF-8#Description

// 110XXXXX

if (i == 1 && c >> 5 == 0x06) {

this.charLength = 2;

break;

}

// 1110XXXX

if (i <= 2 && c >> 4 == 0x0E) {

this.charLength = 3;

break;

}

// 11110XXX

if (i <= 3 && c >> 3 == 0x1E) {

this.charLength = 4;

break;

}

}

if (!this.charLength) {

// no incomplete char at the end of this buffer, emit the whole thing

return charStr + buffer.toString();

}

// buffer the incomplete character bytes we got

buffer.copy(this.charBuffer, 0, buffer.length - i, buffer.length);

this.charReceived = i;

if (buffer.length - i > 0) {

// buffer had more bytes before the incomplete char, emit them

return charStr + buffer.toString('utf8', 0, buffer.length - i);

}

// or just emit the charStr

return charStr;

};