#include "parse.h"

#include "express.h"

#include "character_decoder.h"

#include "exception.h"

#include "file.h"

#include "logger.h"

#include "schema.h"

#include "si_prefix.h"

#include "file_reader.h"

#include "utils.h"

#include <algorithm>

#include <boost/algorithm/string.hpp>

#include <boost/variant.hpp>

#include <boost/math/special_functions/fpclassify.hpp>

#include <ctime>

#include <set>

#include <stdio.h>

#include <stdlib.h>

#include <cstring>

#include <string>

#include <iomanip>

#include <charconv>

#include <type_traits>

#include <unordered_map>

#include <functional>

#include <thread>

#include <exception>

#include <cstdlib>

#if defined(__APPLE__)

#include <xlocale.h>

#include <locale.h>

#endif

#ifdef USE_MMAP

#include <boost/filesystem/path.hpp>

#endif

#define PERMISSIVE_FLOAT

using namespace ifcopenshell;

template <typename Reader>

spf_lexer<Reader>::spf_lexer(Reader* stream_, ifcopenshell::logger& log)

: decoder_(nullptr)

, logger_(log) {

stream = stream_;

decoder_ = new character_decoder<Reader>(stream_, logger_);

}

template <typename Reader>

spf_lexer<Reader>::~spf_lexer() {

delete decoder_;

}

template <typename Reader>

size_t spf_lexer<Reader>::skip_whitespace() const {

size_t index = 0;

while (!stream->eof()) {

char character = stream->peek();

if ((character == ' ' || character == '\r' || character == '\n' || character == '\t')) {

stream->increment();

++index;

} else {

break;

}

}

return index;

}

template <typename Reader>

size_t spf_lexer<Reader>::skip_comment() const {

if (stream->eof()) {

return 0;

}

char character = stream->peek();

if (character != '/') {

return 0;

}

stream->increment();

character = stream->peek();

if (character != '*') {

stream->seek(stream->tell() - 1);

return 0;

}

size_t index = 2;

char intermediate = 0;

while (!stream->eof()) {

character = stream->peek();

stream->increment();

++index;

if (character == '/' && intermediate == '*') {

break;

}

intermediate = character;

}

return index;

}

template <typename Reader>

std::string& spf_lexer<Reader>::get_temp_string() const {

const size_t idx = pool_index++;

const size_t slice = idx >> 4;

const size_t offset = idx & 0xF;

while (stringpool_.size() <= slice) {

stringpool_.push_back(std::make_unique<std::array<std::string, 16>>());

}

// std::wcout << "Num contexts: " << idx << std::endl;

return (*stringpool_[slice])[offset];

}

#if defined(__APPLE__) || defined(__EMSCRIPTEN__)

double ifcopenshell::parse_double_c(const char* start, char** end) {

static const locale_t loc = newlocale(LC_NUMERIC_MASK, "C", (locale_t)0);

return strtod_l(start, end, loc);

}

#endif

template class IFC_PARSE_API ifcopenshell::spf_lexer<file_reader<full_buffer_impl>>;

template class IFC_PARSE_API ifcopenshell::spf_lexer<file_reader<paged_file_impl>>;

template class IFC_PARSE_API ifcopenshell::spf_lexer<file_reader<pushed_sequential_impl>>;

#ifdef USE_MMAP

template class IFC_PARSE_API ifcopenshell::spf_lexer<file_reader<mmap_impl>>;

#endif

#define IFC_INSTANTIATE_LEXER_NEXT(Reader) \

template IFC_PARSE_API token ifcopenshell::spf_lexer<Reader>::next<ifcopenshell::full_tokens>(); \

template IFC_PARSE_API token ifcopenshell::spf_lexer<Reader>::next<ifcopenshell::index_tokens>();

IFC_INSTANTIATE_LEXER_NEXT(file_reader<full_buffer_impl>)

IFC_INSTANTIATE_LEXER_NEXT(file_reader<paged_file_impl>)

IFC_INSTANTIATE_LEXER_NEXT(file_reader<pushed_sequential_impl>)

#ifdef USE_MMAP

IFC_INSTANTIATE_LEXER_NEXT(file_reader<mmap_impl>)

#endif

#undef IFC_INSTANTIATE_LEXER_NEXT

bool token::is_operator() {

return type == Token_OPERATOR;

}

bool token::is_operator(char character) {

return type == Token_OPERATOR && value_char == character;

}

bool token::is_identifier() {

return type == Token_IDENTIFIER;

}

bool token::is_string() {

return type == Token_STRING;

}

bool token::is_enumeration() {

// @nb this is a bit confusing?

return type == Token_ENUMERATION || type == Token_BOOL;

}

bool token::is_binary() {

return type == Token_BINARY;

}

bool token::is_keyword() {

return type == Token_KEYWORD;

}

bool token::is_int() {

return type == Token_INT;

}

bool token::is_bool() {

// Bool and logical share the same storage type, just logical unknown is stored as 'U'.

return type == Token_BOOL && value_char != 'U';

}

bool token::is_logical() {

return type == Token_BOOL;

}

bool token::is_float() {

}

int64_t token::as_int() {

}

unsigned token::as_identifier() {

}

bool token::as_bool() {

}

boost::logic::tribool token::as_logical() {

}

double token::as_float() {

}

const std::string& token::as_string() {

if (is_string() || is_enumeration() || is_binary() || is_keyword()) {

// @todo quotes

return *value_string;

}

throw invalid_token_exception(start_pos, to_string(), "string");

}

boost::dynamic_bitset<> token::as_binary() {

}

std::string token::to_string() {

}

std::string ifcopenshell::encode_spf_string(const std::string& value) {

return character_encoder(value);

}

std::string ifcopenshell::decode_spf_string(const std::string& value) {

}

namespace {

template<typename Variant, typename T>

struct is_type_in_variant;

template<typename T, typename First, typename... Rest>

struct is_type_in_variant<std::variant<First, Rest...>, T>

{

static constexpr bool value = std::is_same<T, First>::value || is_type_in_variant<std::variant<Rest...>, T>::value;

};

template<typename T, typename Last>

struct is_type_in_variant<std::variant<Last>, T>

{

static constexpr bool value = std::is_same<T, Last>::value;

};

template<typename Variant, typename T>

constexpr bool is_type_in_variant_v = is_type_in_variant<Variant, T>::value;

class parameter_type_view {

};

const ifcopenshell::parameter_type* unwrap_type_declarations(const ifcopenshell::parameter_type* parameter_type) {

while (parameter_type && parameter_type->as_named_type() &&

parameter_type->as_named_type()->declared_type()->as_type_declaration()) {

parameter_type = parameter_type->as_named_type()->declared_type()->as_type_declaration()->declared_type();

}

return parameter_type;

}

ifcopenshell::declaration* declared_type(const ifcopenshell::parameter_type* parameter_type) {

parameter_type = unwrap_type_declarations(parameter_type);

return parameter_type && parameter_type->as_named_type() ? parameter_type->as_named_type()->declared_type() : nullptr;

}

const ifcopenshell::aggregation_type* aggregate_parameter_type(const ifcopenshell::parameter_type* parameter_type) {

parameter_type = unwrap_type_declarations(parameter_type);

return parameter_type ? parameter_type->as_aggregation_type() : nullptr;

}

const ifcopenshell::aggregation_type* nested_aggregation_type(const ifcopenshell::aggregation_type* aggregate_type) {

return aggregate_type ? aggregate_parameter_type(aggregate_type->type_of_element()) : nullptr;

}

void warn_attribute_count(

}

template <typename Fn>

void dispatch_token_direct(ifcopenshell::token token, ifcopenshell::declaration* declaration, int attribute_index, logger& logger, Fn&& fn) {

}

typedef std::variant<

blank,

std::vector<int64_t>,

std::vector<double>,

std::vector<std::string>,

std::vector<boost::dynamic_bitset<>>,

std::vector<ifcopenshell::reference_or_simple_type>,

std::vector<std::vector<int64_t>>,

std::vector<std::vector<double>>,

std::vector<std::vector<ifcopenshell::reference_or_simple_type>>

> direct_aggregate_storage;

struct direct_aggregate {

};

void append_empty_direct_aggregate(const ifcopenshell::aggregation_type* aggregate_type, direct_aggregate& target) {

}

template <typename T>

void set_direct_attribute(

}

template <typename Reader>

void skip_aggregate(ifcopenshell::spf_lexer<Reader>* tokens) {

}

template <typename Reader>

direct_aggregate read_direct_aggregate(

}

} // namespace

template <typename Reader>

shared_pointer_type ifcopenshell::impl::in_memory_file_storage::load(

ifcopenshell::spf_lexer<Reader>* tokens,

std::optional<size_t> entity_instance_name,

const ifcopenshell::declaration* declaration,

const ifcopenshell::entity* entity,

int attribute_index,

bool coerce_attribute_count

) {

static_cast<void>(coerce_attribute_count);

auto storage = load_attributes<Reader, in_memory_attribute_storage>(tokens, entity_instance_name, declaration, entity, attribute_index);

return ifcopenshell::make_pointer_type<instance_data>(file, declaration, (declaration && declaration->as_entity()) ? (uint32_t)entity_instance_name.value_or(0) : 0, std::move(storage));

}

template <typename Reader, typename Storage>

Storage ifcopenshell::impl::in_memory_file_storage::load_attributes(

ifcopenshell::spf_lexer<Reader>* tokens,

std::optional<size_t> entity_instance_name,

const ifcopenshell::declaration* declaration,

const ifcopenshell::entity* entity,

int attribute_index

) {

parameter_type_view parameter_types(declaration);

const size_t expected_size = parameter_types.size();

Storage storage(expected_size);

token next = tokens->next();

size_t attribute_index_within_data = 0;

size_t values_read = 0;

while (next) {

if (next.is_operator(',')) {

++attribute_index_within_data;

} else if (next.is_operator(')')) {

break;

} else {

++values_read;

const bool retain_value = attribute_index_within_data < expected_size;

const ifcopenshell::parameter_type* parameter_type = retain_value ? parameter_types[attribute_index_within_data] : nullptr;

const int reference_attribute_index = attribute_index == -1 ? (int) attribute_index_within_data : attribute_index;

if (next.is_operator('(')) {

if (retain_value) {

auto aggregate = read_direct_aggregate(*this, tokens, entity_instance_name, entity, reference_attribute_index, aggregate_parameter_type(parameter_type), logger_.get());

std::visit([&](const auto& value) {

if constexpr (!std::is_same_v<std::decay_t<decltype(value)>, blank>) {

set_direct_attribute(storage, entity_instance_name, references_to_resolve, resolve_references_in_place, attribute_index_within_data, attribute_index, value);

}

}, aggregate.storage);

} else {

skip_aggregate(tokens);

}

} else if (next.is_keyword()) {

try {

const auto* simple_declaration = (schema ? schema : file->schema())->declaration_by_name(next.as_string());

tokens->next();

if (retain_value) {

auto data = load(tokens, entity_instance_name, simple_declaration, entity, reference_attribute_index);

read_simple_type_instances.push_back(data);

storage.set(attribute_index_within_data, express::base(data));

} else {

skip_aggregate(tokens);

}

} catch (exception& e) {

logger_.get().message(ifcopenshell::logger::LOG_ERROR, std::string(e.what()) + " at offset " + std::to_string(next.start_pos));

--values_read;

}

} else {

if (next.is_identifier() && entity && entity_instance_name) {

register_inverse((unsigned)*entity_instance_name, entity, next.value_int, reference_attribute_index);

}

if (retain_value) {

dispatch_token_direct(next, declared_type(parameter_type), (int) attribute_index_within_data, logger_.get(), [&](const auto& value) {

set_direct_attribute(storage, entity_instance_name, references_to_resolve, resolve_references_in_place, attribute_index_within_data, attribute_index, value);

});

}

}

}

next = tokens->next();

}

warn_attribute_count(declaration, entity_instance_name, expected_size, values_read, logger_.get());

return storage;

}

template <typename Reader>

void ifcopenshell::impl::in_memory_file_storage::try_read_semicolon(ifcopenshell::spf_lexer<Reader>* tokens) const {

auto old_offset = tokens->stream->tell();

token semilocon = tokens->next();

if (!semilocon.is_operator(';')) {

tokens->stream->seek(old_offset);

}

}

void ifcopenshell::impl::in_memory_file_storage::register_inverse(unsigned id_from, const ifcopenshell::entity* from_entity, int inst_id, int attribute_index) {

if (!register_inverses_) {

return;

}

// Assume a check on token type has already been performed

byref_excl_.add((uint32_t)inst_id, (uint32_t)id_from, (uint16_t)from_entity->index_in_schema(), attribute_index);

}

void ifcopenshell::impl::in_memory_file_storage::unregister_inverse(unsigned id_from, const ifcopenshell::entity* from_entity, const express::base& inst, int attribute_index) {

if (!byref_excl_.remove((uint32_t)inst.id(), (uint32_t)id_from, (uint16_t)from_entity->index_in_schema(), attribute_index)) {

// @todo inverses also need to be populated when multiple instances are added to a new file.

// throw ifcopenshell::exception("Instance not found among inverses");

}

}

namespace {

template <typename T>

std::string to_string_fixed_width(const T& t, size_t) {

}

}

void ifcopenshell::impl::rocks_db_file_storage::register_inverse(unsigned id_from, const ifcopenshell::entity* from_entity, int inst_id, int attribute_index) {

#ifndef IFOPSH_WITH_ROCKSDB

(void)id_from;

(void)from_entity;

(void)inst_id;

(void)attribute_index;

#endif

#ifdef IFOPSH_WITH_ROCKSDB

static std::string s;

uint32_t v = id_from;

s.resize(sizeof(uint32_t));

memcpy(s.data(), &v, sizeof(uint32_t));

auto key = "v|" + to_string_fixed_width(inst_id, 10) + "|" + to_string_fixed_width(from_entity->index_in_schema(), 4) + "|" + to_string_fixed_width(attribute_index, 2);

db->Merge(wopts, key, s);

/*

#endif

}

void ifcopenshell::impl::rocks_db_file_storage::unregister_inverse(unsigned id_from, const ifcopenshell::entity* from_entity, const express::base& inst, int attribute_index) {

#ifndef IFOPSH_WITH_ROCKSDB

(void)id_from;

(void)from_entity;

(void)inst;

(void)attribute_index;

#endif

#ifdef IFOPSH_WITH_ROCKSDB

static std::string s;

auto inst_id = inst.id();

auto key = "v|" + to_string_fixed_width(inst_id, 10) + "|" + to_string_fixed_width(from_entity->index_in_schema(), 4) + "|" + to_string_fixed_width(attribute_index, 2);

if (db->Get(rocksdb::ReadOptions{}, key, &s).ok()) {

std::vector<uint32_t> vals(s.size() / sizeof(uint32_t));

memcpy(vals.data(), s.data(), s.size());

auto it = std::find(vals.begin(), vals.end(), (uint32_t)id_from);

if (it != vals.end()) {

vals.erase(it);

} else {

file->logger().error("Unregistering non-existant inverse #" + std::to_string(id_from) + " on instance #" + std::to_string(inst_id) + " at attribute " + std::to_string(attribute_index));

}

s.resize(vals.size() * sizeof(uint32_t));

memcpy(s.data(), vals.data(), s.size());

db->Put(wopts, key, s);

}

#endif

}

void ifcopenshell::impl::rocks_db_file_storage::add_type_ref(const express::base& new_entity)

{

#ifndef IFOPSH_WITH_ROCKSDB

(void)new_entity;

#endif

#ifdef IFOPSH_WITH_ROCKSDB

size_t v;

std::string s(sizeof(size_t), ' ');

if (new_entity.declaration().as_entity()) {

v = new_entity.id();

memcpy(s.data(), &v, sizeof(size_t));

// no merges yet, because the python client doesn't support them

db->Merge(wopts, "t|" + std::to_string(new_entity.declaration().index_in_schema()), s);

/*{

}

// not only mapping also register type

v = new_entity.declaration().index_in_schema();

memcpy(s.data(), &v, sizeof(size_t));

db->Put(wopts, (new_entity.declaration().as_entity() ? "i|" : "t|") + std::to_string(new_entity.id() ? new_entity.id() : new_entity.identity()) + "|_", s);

#endif

}

void ifcopenshell::impl::rocks_db_file_storage::remove_type_ref(const express::base& new_entity)

{

#ifndef IFOPSH_WITH_ROCKSDB

(void)new_entity;

#endif

#ifdef IFOPSH_WITH_ROCKSDB

if (new_entity.declaration().as_entity()) {

std::string s;

auto key = "t|" + std::to_string(new_entity.declaration().index_in_schema());

if (db->Get(rocksdb::ReadOptions{}, key, &s).ok()) {

std::vector<size_t> vals(s.size() / sizeof(size_t));

memcpy(vals.data(), s.data(), s.size());

vals.erase(std::find(vals.begin(), vals.end(), (size_t)new_entity.id()));

s.resize(vals.size() * sizeof(size_t));