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
|
/*
* Copyright 2017 WebAssembly Community Group participants
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "src/lexer-source.h"
#include <algorithm>
namespace wabt {
LexerSourceFile::LexerSourceFile(const std::string& filename)
: filename_(filename) {
file_ = fopen(filename.c_str(), "rb");
}
LexerSourceFile::~LexerSourceFile() {
if (file_)
fclose(file_);
}
std::unique_ptr<LexerSource> LexerSourceFile::Clone() {
std::unique_ptr<LexerSourceFile> result(new LexerSourceFile(filename_));
Offset offset = 0;
if (Failed(Tell(&offset)) || Failed(result->Seek(offset)))
result.reset();
return std::move(result);
}
Result LexerSourceFile::Tell(Offset* out_offset) {
if (!file_)
return Result::Error;
long offset = ftell(file_);
if (offset < 0)
return Result::Error;
*out_offset = offset;
return Result::Ok;
}
size_t LexerSourceFile::Fill(void* dest, size_t size) {
if (!file_)
return 0;
return fread(dest, 1, size, file_);
}
Result LexerSourceFile::ReadRange(OffsetRange range,
std::vector<char>* out_data) {
Offset old_offset = 0;
CHECK_RESULT(Tell(&old_offset));
CHECK_RESULT(Seek(range.start));
std::vector<char> result(range.size());
if (range.size() > 0) {
size_t read_size = Fill(result.data(), range.size());
if (read_size < range.size())
result.resize(read_size);
}
CHECK_RESULT(Seek(old_offset));
*out_data = std::move(result);
return Result::Ok;
}
Result LexerSourceFile::Seek(Offset offset) {
if (!file_)
return Result::Error;
int result = fseek(file_, offset, SEEK_SET);
return result < 0 ? Result::Error : Result::Ok;
}
LexerSourceBuffer::LexerSourceBuffer(const void* data, Offset size)
: data_(data), size_(size), read_offset_(0) {}
std::unique_ptr<LexerSource> LexerSourceBuffer::Clone() {
LexerSourceBuffer* result = new LexerSourceBuffer(data_, size_);
result->read_offset_ = read_offset_;
return std::unique_ptr<LexerSource>(result);
}
Result LexerSourceBuffer::Tell(Offset* out_offset) {
*out_offset = read_offset_;
return Result::Ok;
}
size_t LexerSourceBuffer::Fill(void* dest, Offset size) {
Offset read_size = std::min(size, size_ - read_offset_);
if (read_size > 0) {
const void* src = static_cast<const char*>(data_) + read_offset_;
memcpy(dest, src, read_size);
read_offset_ += read_size;
}
return read_size;
}
Result LexerSourceBuffer::ReadRange(OffsetRange range,
std::vector<char>* out_data) {
OffsetRange clamped = range;
clamped.start = std::min(clamped.start, size_);
clamped.end = std::min(clamped.end, size_);
if (clamped.size()) {
out_data->resize(clamped.size());
const void* src = static_cast<const char*>(data_) + clamped.start;
memcpy(out_data->data(), src, clamped.size());
}
return Result::Ok;
}
} // namespace wabt
|
