#include <assert.h>

#include <stdarg.h>

#include <fstream>

#include <mutex>

#include "attachment.hpp"

#include "cleanup.hpp"

#include "internal.hpp"

#include "io.hpp"

#include "modulefinder.hpp"

#include "options.hpp"

#include "scope.hpp"

#include "transports/base_transport.hpp"

#include "unwind.hpp"

#include "uuid.hpp"

#include "value.hpp"

using namespace sentry;

static sentry_options_t *g_options;

static bool sdk_disabled() {

return !g_options || g_options->dsn.disabled();

}

int sentry_init(sentry_options_t *options) {

}

void sentry_shutdown(void) {

}

void sentry_user_consent_give(void) {

}

void sentry_user_consent_revoke(void) {

}

void sentry_user_consent_reset(void) {

}

sentry_user_consent_t sentry_user_consent_get(void) {

return g_options->user_consent;

}

const sentry_options_t *sentry_get_options(void) {

return g_options;

}

sentry_uuid_t sentry_capture_event(sentry_value_t evt) {

}

void sentry_add_breadcrumb(sentry_value_t breadcrumb) {

}

void sentry_set_user(sentry_value_t value) {

Scope::with_scope_mut(

[value](Scope &scope) { scope.user = Value::consume(value); });

}

void sentry_remove_user() {

Scope::with_scope_mut([](Scope &scope) { scope.user = Value(); });

}

void sentry_set_tag(const char *key, const char *value) {

}

void sentry_remove_tag(const char *key) {

Scope::with_scope_mut(

[key](Scope &scope) { scope.tags.remove_by_key(key); });

}

void sentry_set_extra(const char *key, sentry_value_t value) {

}

void sentry_remove_extra(const char *key) {

Scope::with_scope_mut(

[key](Scope &scope) { scope.extra.remove_by_key(key); });

}

void sentry_set_context(const char *key, sentry_value_t value) {

}

void sentry_remove_context(const char *key) {

Scope::with_scope_mut(

[key](Scope &scope) { scope.contexts.remove_by_key(key); });

}

void sentry_set_fingerprint(const char *fingerprint, ...) {

}

void sentry_remove_fingerprint(void) {

sentry_set_fingerprint(nullptr);

}

void sentry_set_transaction(const char *transaction) {

Scope::with_scope_mut(

[transaction](Scope &scope) { scope.transaction = transaction; });

}

void sentry_remove_transaction() {

sentry_set_transaction("");

}

void sentry_set_level(sentry_level_t level) {

Scope::with_scope_mut([level](Scope &scope) { scope.level = level; });

}

void sentry_string_free(char *str) {

free(str);

}

size_t sentry_unwind_stack(void *addr, void **stacktrace_out, size_t max_len) {

return unwind_stack(addr, nullptr, stacktrace_out, max_len);

}

size_t sentry_unwind_stack_from_ucontext(const sentry_ucontext_t *uctx,

}

sentry_value_t sentry_envelope_get_event(const sentry_envelope_t *envelope) {

const transports::Envelope *e = (const transports::Envelope *)envelope;

return e->get_event().lower_decref();

}

char *sentry_envelope_serialize(const sentry_envelope_t *envelope,

size_t *size_out) {

const transports::Envelope *e = (const transports::Envelope *)envelope;

return e->serialize(size_out);

}

int sentry_envelope_write_to_file(const sentry_envelope_t *envelope,

}