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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
#include "stdafx.h"
#include "Buffer.h"
#include "Core/CloneEnv.h"
#include "Core/Str.h"
#include "Core/StrBuf.h"
#include "Core/Convert.h"
#include "Core/Exception.h"
namespace storm {
Buffer::Buffer() : data(null) {}
Buffer::Buffer(GcArray<Byte> *buf) : data(buf) {}
void Buffer::shift(Nat n) {
if (n >= filled()) {
filled(0);
} else {
memmove(data->v, data->v + n, filled() - n);
filled(filled() - n);
}
}
Bool Buffer::push(Byte b) {
if (!data)
return false;
if (data->filled >= data->count)
return false;
data->v[data->filled++] = b;
return true;
}
void Buffer::deepCopy(CloneEnv *env) {
if (data) {
GcArray<Byte> *n = runtime::allocBuffer(env->engine(), data->count);
n->filled = data->filled;
for (nat i = 0; i < data->count; i++)
n->v[i] = data->v[i];
data = n;
}
}
void Buffer::throwOutOfBounds(Nat id) const {
throw new (runtime::someEngine()) ArrayError(id, count());
}
Buffer buffer(EnginePtr e, Nat count) {
return Buffer(runtime::allocBuffer(e.v, count));
}
Buffer emptyBuffer(GcArray<Byte> *data) {
Buffer r(data);
r.filled(0);
return r;
}
Buffer fullBuffer(GcArray<Byte> *data) {
Buffer r(data);
r.filled(Nat(data->count));
return r;
}
Buffer buffer(EnginePtr e, const Byte *data, Nat count) {
Buffer z(runtime::allocBuffer(e.v, count));
memcpy(z.dataPtr(), data, count);
z.filled(count);
return z;
}
Buffer grow(EnginePtr e, Buffer src, Nat newCount) {
Buffer r = buffer(e, newCount);
memcpy(r.dataPtr(), src.dataPtr(), src.filled());
r.filled(src.filled());
return r;
}
Buffer cut(EnginePtr e, Buffer src, Nat from) {
return cut(e, src, from, src.count());
}
Buffer cut(EnginePtr e, Buffer src, Nat from, Nat to) {
if (to <= from)
return buffer(e, 0);
Buffer r = buffer(e, to - from);
if (src.filled() > from) {
Nat copy = min(to, src.filled()) - from;
memcpy(r.dataPtr(), src.dataPtr() + from, copy);
r.filled(copy);
} else {
r.filled(0);
}
return r;
}
void Buffer::toS(StrBuf *to) const {
outputMark(to, count() + 1);
}
void Buffer::outputMark(StrBuf *to, Nat mark) const {
const Nat width = 16;
for (Nat i = 0; i <= count(); i++) {
if (i % width == 0) {
if (i > 0)
*to << S("\n");
*to << hex(i) << S(" ");
}
if (i == filled() && i == mark)
*to << S("|>");
else if (i == filled())
*to << S("| ");
else if (i == mark)
*to << S(" >");
else
*to << S(" ");
if (i < count())
*to << hex((*this)[i]);
}
}
Buffer toUtf8(Str *str) {
return fullBuffer((GcArray<Byte> *)toCharNoNull(str->engine(), str->c_str(), str->peekLength()));
}
Str *fromUtf8(EnginePtr e, Buffer buffer) {
return new (e.v) Str(toWChar(e.v, (const char *)buffer.dataPtr(), buffer.filled()));
}
}
|
