RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 04:17:35 +00:00
Code Issues Activity Actions

LibPDF: Replace Value class by AK::Variant

Browse source 
This decreases the memory consumption by LibPDF by 4 bytes per Value,
compensating exactly for the increase in an earlier commit. :^)
This commit is contained in:
Ben Wiederhake 2021-09-19 20:56:05 +02:00 • committed by Ali Mohammad Pur
parent d344253b08
commit f84a7e2e22
7 changed files with 132 additions and 243 deletions
Download patch file Download diff file Expand all files Collapse all files

86
Userland/Libraries/LibPDF/Parser.cpp
View file

@ -125,10 +125,10 @@ Parser::LinearizationResult Parser::initialize_linearization_dict()
{
// parse_header() is called immediately before this, so we are at the right location
auto dict_value = m_document->resolve(parse_indirect_value());
if (!dict_value || !dict_value.is_object())
if (!dict_value.has<NonnullRefPtr<Object>>())
return LinearizationResult::Error;
auto dict_object = dict_value.as_object();
auto dict_object = dict_value.get<NonnullRefPtr<Object>>();
if (!dict_object->is_dict())
return LinearizationResult::NotLinearized;
@ -149,16 +149,16 @@ Parser::LinearizationResult Parser::initialize_linearization_dict()
auto first_page = dict->get(CommonNames::P).value_or({});
// Validation
if (!length_of_file.is_int_type<u32>()
|| !hint_table.is_object()
|| !first_page_object_number.is_int_type<u32>()
|| !number_of_pages.is_int_type<u16>()
|| !offset_of_main_xref_table.is_int_type<u32>()
|| (first_page && !first_page.is_int_type<u32>())) {
if (!length_of_file.has_u32()
|| !hint_table.has<NonnullRefPtr<Object>>()
|| !first_page_object_number.has_u32()
|| !number_of_pages.has_u16()
|| !offset_of_main_xref_table.has_u32()
|| (!first_page.has<Empty>() && !first_page.has_u32())) {
return LinearizationResult::Error;
}
auto hint_table_object = hint_table.as_object();
auto hint_table_object = hint_table.get<NonnullRefPtr<Object>>();
if (!hint_table_object->is_array())
return LinearizationResult::Error;
@ -177,24 +177,24 @@ Parser::LinearizationResult Parser::initialize_linearization_dict()
overflow_hint_stream_length = hint_table_array->at(3);
}
if (!primary_hint_stream_offset.is_int_type<u32>()
|| !primary_hint_stream_length.is_int_type<u32>()
|| (overflow_hint_stream_offset && !overflow_hint_stream_offset.is_int_type<u32>())
|| (overflow_hint_stream_length && !overflow_hint_stream_length.is_int_type<u32>())) {
if (!primary_hint_stream_offset.has_u32()
|| !primary_hint_stream_length.has_u32()
|| (!overflow_hint_stream_offset.has<Empty>() && !overflow_hint_stream_offset.has_u32())
|| (!overflow_hint_stream_length.has<Empty>() && !overflow_hint_stream_length.has_u32())) {
return LinearizationResult::Error;
}
m_linearization_dictionary = LinearizationDictionary {
length_of_file.as_int_type<u32>(),
primary_hint_stream_offset.as_int_type<u32>(),
primary_hint_stream_length.as_int_type<u32>(),
overflow_hint_stream_offset ? overflow_hint_stream_offset.as_int_type<u32>() : NumericLimits<u32>::max(),
overflow_hint_stream_length ? overflow_hint_stream_length.as_int_type<u32>() : NumericLimits<u32>::max(),
first_page_object_number.as_int_type<u32>(),
offset_of_first_page_end.as_int_type<u32>(),
number_of_pages.as_int_type<u16>(),
offset_of_main_xref_table.as_int_type<u32>(),
first_page ? first_page.as_int_type<u32>() : NumericLimits<u32>::max(),
length_of_file.get_u32(),
primary_hint_stream_offset.get_u32(),
primary_hint_stream_length.get_u32(),
overflow_hint_stream_offset.has<Empty>() ? NumericLimits<u32>::max() : overflow_hint_stream_offset.get_u32(),
overflow_hint_stream_length.has<Empty>() ? NumericLimits<u32>::max() : overflow_hint_stream_length.get_u32(),
first_page_object_number.get_u32(),
offset_of_first_page_end.get_u32(),
number_of_pages.get_u16(),
offset_of_main_xref_table.get_u32(),
first_page.has<Empty>() ? NumericLimits<u32>::max() : first_page.get_u32(),
};
return LinearizationResult::Linearized;
@ -241,10 +241,10 @@ bool Parser::initialize_hint_tables()
return {};
auto stream_value = stream_indirect_value->value();
if (!stream_value.is_object())
if (!stream_value.has<NonnullRefPtr<Object>>())
return {};
auto stream_object = stream_value.as_object();
auto stream_object = stream_value.get<NonnullRefPtr<Object>>();
if (!stream_object->is_stream())
return {};
@ -310,9 +310,9 @@ bool Parser::initialize_non_linearized_xref_table()
m_reader.set_reading_forwards();
auto xref_offset_value = parse_number();
if (!xref_offset_value.is_int())
if (!xref_offset_value.has<int>())
return false;
auto xref_offset = xref_offset_value.as_int();
auto xref_offset = xref_offset_value.get<int>();
m_reader.move_to(xref_offset);
m_xref_table = parse_xref_table();
@ -339,9 +339,9 @@ RefPtr<XRefTable> Parser::parse_xref_table()
Vector<XRefEntry> entries;
auto starting_index_value = parse_number();
auto starting_index = starting_index_value.as_int();
auto starting_index = starting_index_value.get<int>();
auto object_count_value = parse_number();
auto object_count = object_count_value.as_int();
auto object_count = object_count_value.get<int>();
for (int i = 0; i < object_count; i++) {
auto offset_string = String(m_reader.bytes().slice(m_reader.offset(), 10));
@ -603,7 +603,7 @@ Value Parser::parse_value()
if (m_reader.matches("null")) {
m_reader.move_by(4);
consume_whitespace();
return Value(Value::NullTag {});
return Value(nullptr);
}
if (m_reader.matches("true")) {
@ -646,12 +646,12 @@ Value Parser::parse_value()
Value Parser::parse_possible_indirect_value_or_ref()
{
auto first_number = parse_number();
if (!first_number.is_int() || !matches_number())
if (!first_number.has<int>() || !matches_number())
return first_number;
m_reader.save();
auto second_number = parse_number();
if (!second_number.is_int()) {
if (!second_number.has<int>()) {
m_reader.load();
return first_number;
}
@ -660,12 +660,12 @@ Value Parser::parse_possible_indirect_value_or_ref()
m_reader.discard();
consume();
consume_whitespace();
return Value(Reference(first_number.as_int(), second_number.as_int()));
return Value(Reference(first_number.get<int>(), second_number.get<int>()));
}
if (m_reader.matches("obj")) {
m_reader.discard();
return parse_indirect_value(first_number.as_int(), second_number.as_int());
return parse_indirect_value(first_number.get<int>(), second_number.get<int>());
}
m_reader.load();
@ -692,12 +692,12 @@ RefPtr<IndirectValue> Parser::parse_indirect_value(int index, int generation)
RefPtr<IndirectValue> Parser::parse_indirect_value()
{
auto first_number = parse_number();
if (!first_number.is_int())
if (!first_number.has<int>())
return {};
auto second_number = parse_number();
if (!second_number.is_int())
if (!second_number.has<int>())
return {};
return parse_indirect_value(first_number.as_int(), second_number.as_int());
return parse_indirect_value(first_number.get<int>(), second_number.get<int>());
}
Value Parser::parse_number()
@ -928,7 +928,7 @@ RefPtr<ArrayObject> Parser::parse_array()
while (!m_reader.matches(']')) {
auto value = parse_value();
if (!value)
if (value.has<Empty>())
return {};
values.append(value);
}
@ -954,7 +954,7 @@ RefPtr<DictObject> Parser::parse_dict()
if (!name)
return {};
auto value = parse_value();
if (!value)
if (value.has<Empty>())
return {};
map.set(name->name(), value);
}
@ -1004,14 +1004,14 @@ RefPtr<DictObject> Parser::conditionally_parse_page_tree_node(u32 object_index,
return {};
}
auto value = parse_value();
if (!value) {
if (value.has<Empty>()) {
ok = false;
return {};
}
if (name_string == CommonNames::Type) {
if (!value.is_object())
if (!value.has<NonnullRefPtr<Object>>())
return {};
auto type_object = value.as_object();
auto type_object = value.get<NonnullRefPtr<Object>>();
if (!type_object->is_name())
return {};
auto type_name = object_cast<NameObject>(type_object);
@ -1039,7 +1039,7 @@ RefPtr<StreamObject> Parser::parse_stream(NonnullRefPtr<DictObject> dict)
ReadonlyBytes bytes;
auto maybe_length = dict->get(CommonNames::Length);
if (maybe_length.has_value() && (!maybe_length->is_ref() || m_xref_table)) {
if (maybe_length.has_value() && (!maybe_length->has<Reference>() || m_xref_table)) {
// The PDF writer has kindly provided us with the direct length of the stream
m_reader.save();
auto length = m_document->resolve_to<int>(maybe_length.value());