mirror of
https://git.suyu.dev/suyu/breakpad.git
synced 2025-12-28 02:05:04 +01:00
64506d2ed7
git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@671 4c0a9323-5329-0410-9bdc-e9ce6186880e
2505 lines
86 KiB
C++
2505 lines
86 KiB
C++
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
|
|
#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
|
|
#include "process_state.pb.h"
|
|
#include <google/protobuf/stubs/once.h>
|
|
#include <google/protobuf/io/coded_stream.h>
|
|
#include <google/protobuf/wire_format_lite_inl.h>
|
|
#include <google/protobuf/descriptor.h>
|
|
#include <google/protobuf/reflection_ops.h>
|
|
#include <google/protobuf/wire_format.h>
|
|
// @@protoc_insertion_point(includes)
|
|
|
|
namespace google_breakpad {
|
|
|
|
namespace {
|
|
|
|
const ::google::protobuf::Descriptor* ProcessStateProto_descriptor_ = NULL;
|
|
const ::google::protobuf::internal::GeneratedMessageReflection*
|
|
ProcessStateProto_reflection_ = NULL;
|
|
const ::google::protobuf::Descriptor* ProcessStateProto_Crash_descriptor_ = NULL;
|
|
const ::google::protobuf::internal::GeneratedMessageReflection*
|
|
ProcessStateProto_Crash_reflection_ = NULL;
|
|
const ::google::protobuf::Descriptor* ProcessStateProto_Thread_descriptor_ = NULL;
|
|
const ::google::protobuf::internal::GeneratedMessageReflection*
|
|
ProcessStateProto_Thread_reflection_ = NULL;
|
|
const ::google::protobuf::Descriptor* StackFrame_descriptor_ = NULL;
|
|
const ::google::protobuf::internal::GeneratedMessageReflection*
|
|
StackFrame_reflection_ = NULL;
|
|
const ::google::protobuf::Descriptor* CodeModule_descriptor_ = NULL;
|
|
const ::google::protobuf::internal::GeneratedMessageReflection*
|
|
CodeModule_reflection_ = NULL;
|
|
|
|
} // namespace
|
|
|
|
|
|
void protobuf_AssignDesc_process_5fstate_2eproto() {
|
|
protobuf_AddDesc_process_5fstate_2eproto();
|
|
const ::google::protobuf::FileDescriptor* file =
|
|
::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
|
|
"process_state.proto");
|
|
GOOGLE_CHECK(file != NULL);
|
|
ProcessStateProto_descriptor_ = file->message_type(0);
|
|
static const int ProcessStateProto_offsets_[12] = {
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, time_date_stamp_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, crash_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, assertion_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, requesting_thread_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, threads_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, modules_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, os_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, os_short_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, os_version_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, cpu_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, cpu_info_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, cpu_count_),
|
|
};
|
|
ProcessStateProto_reflection_ =
|
|
new ::google::protobuf::internal::GeneratedMessageReflection(
|
|
ProcessStateProto_descriptor_,
|
|
ProcessStateProto::default_instance_,
|
|
ProcessStateProto_offsets_,
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, _has_bits_[0]),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto, _unknown_fields_),
|
|
-1,
|
|
::google::protobuf::DescriptorPool::generated_pool(),
|
|
::google::protobuf::MessageFactory::generated_factory(),
|
|
sizeof(ProcessStateProto));
|
|
ProcessStateProto_Crash_descriptor_ = ProcessStateProto_descriptor_->nested_type(0);
|
|
static const int ProcessStateProto_Crash_offsets_[2] = {
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto_Crash, reason_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto_Crash, address_),
|
|
};
|
|
ProcessStateProto_Crash_reflection_ =
|
|
new ::google::protobuf::internal::GeneratedMessageReflection(
|
|
ProcessStateProto_Crash_descriptor_,
|
|
ProcessStateProto_Crash::default_instance_,
|
|
ProcessStateProto_Crash_offsets_,
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto_Crash, _has_bits_[0]),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto_Crash, _unknown_fields_),
|
|
-1,
|
|
::google::protobuf::DescriptorPool::generated_pool(),
|
|
::google::protobuf::MessageFactory::generated_factory(),
|
|
sizeof(ProcessStateProto_Crash));
|
|
ProcessStateProto_Thread_descriptor_ = ProcessStateProto_descriptor_->nested_type(1);
|
|
static const int ProcessStateProto_Thread_offsets_[1] = {
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto_Thread, frames_),
|
|
};
|
|
ProcessStateProto_Thread_reflection_ =
|
|
new ::google::protobuf::internal::GeneratedMessageReflection(
|
|
ProcessStateProto_Thread_descriptor_,
|
|
ProcessStateProto_Thread::default_instance_,
|
|
ProcessStateProto_Thread_offsets_,
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto_Thread, _has_bits_[0]),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessStateProto_Thread, _unknown_fields_),
|
|
-1,
|
|
::google::protobuf::DescriptorPool::generated_pool(),
|
|
::google::protobuf::MessageFactory::generated_factory(),
|
|
sizeof(ProcessStateProto_Thread));
|
|
StackFrame_descriptor_ = file->message_type(1);
|
|
static const int StackFrame_offsets_[7] = {
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, instruction_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, module_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, function_name_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, function_base_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, source_file_name_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, source_line_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, source_line_base_),
|
|
};
|
|
StackFrame_reflection_ =
|
|
new ::google::protobuf::internal::GeneratedMessageReflection(
|
|
StackFrame_descriptor_,
|
|
StackFrame::default_instance_,
|
|
StackFrame_offsets_,
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, _has_bits_[0]),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, _unknown_fields_),
|
|
-1,
|
|
::google::protobuf::DescriptorPool::generated_pool(),
|
|
::google::protobuf::MessageFactory::generated_factory(),
|
|
sizeof(StackFrame));
|
|
CodeModule_descriptor_ = file->message_type(2);
|
|
static const int CodeModule_offsets_[7] = {
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeModule, base_address_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeModule, size_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeModule, code_file_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeModule, code_identifier_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeModule, debug_file_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeModule, debug_identifier_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeModule, version_),
|
|
};
|
|
CodeModule_reflection_ =
|
|
new ::google::protobuf::internal::GeneratedMessageReflection(
|
|
CodeModule_descriptor_,
|
|
CodeModule::default_instance_,
|
|
CodeModule_offsets_,
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeModule, _has_bits_[0]),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeModule, _unknown_fields_),
|
|
-1,
|
|
::google::protobuf::DescriptorPool::generated_pool(),
|
|
::google::protobuf::MessageFactory::generated_factory(),
|
|
sizeof(CodeModule));
|
|
}
|
|
|
|
namespace {
|
|
|
|
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
|
|
inline void protobuf_AssignDescriptorsOnce() {
|
|
::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
|
|
&protobuf_AssignDesc_process_5fstate_2eproto);
|
|
}
|
|
|
|
void protobuf_RegisterTypes(const ::std::string&) {
|
|
protobuf_AssignDescriptorsOnce();
|
|
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
|
|
ProcessStateProto_descriptor_, &ProcessStateProto::default_instance());
|
|
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
|
|
ProcessStateProto_Crash_descriptor_, &ProcessStateProto_Crash::default_instance());
|
|
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
|
|
ProcessStateProto_Thread_descriptor_, &ProcessStateProto_Thread::default_instance());
|
|
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
|
|
StackFrame_descriptor_, &StackFrame::default_instance());
|
|
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
|
|
CodeModule_descriptor_, &CodeModule::default_instance());
|
|
}
|
|
|
|
} // namespace
|
|
|
|
void protobuf_ShutdownFile_process_5fstate_2eproto() {
|
|
delete ProcessStateProto::default_instance_;
|
|
delete ProcessStateProto_reflection_;
|
|
delete ProcessStateProto_Crash::default_instance_;
|
|
delete ProcessStateProto_Crash_reflection_;
|
|
delete ProcessStateProto_Thread::default_instance_;
|
|
delete ProcessStateProto_Thread_reflection_;
|
|
delete StackFrame::default_instance_;
|
|
delete StackFrame_reflection_;
|
|
delete CodeModule::default_instance_;
|
|
delete CodeModule_reflection_;
|
|
}
|
|
|
|
void protobuf_AddDesc_process_5fstate_2eproto() {
|
|
static bool already_here = false;
|
|
if (already_here) return;
|
|
already_here = true;
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
|
|
"\n\023process_state.proto\022\017google_breakpad\"\302"
|
|
"\003\n\021ProcessStateProto\022\027\n\017time_date_stamp\030"
|
|
"\001 \001(\003\0227\n\005crash\030\002 \001(\0132(.google_breakpad.P"
|
|
"rocessStateProto.Crash\022\021\n\tassertion\030\003 \001("
|
|
"\t\022\031\n\021requesting_thread\030\004 \001(\005\022:\n\007threads\030"
|
|
"\005 \003(\0132).google_breakpad.ProcessStateProt"
|
|
"o.Thread\022,\n\007modules\030\006 \003(\0132\033.google_break"
|
|
"pad.CodeModule\022\n\n\002os\030\007 \001(\t\022\020\n\010os_short\030\010"
|
|
" \001(\t\022\022\n\nos_version\030\t \001(\t\022\013\n\003cpu\030\n \001(\t\022\020\n"
|
|
"\010cpu_info\030\013 \001(\t\022\021\n\tcpu_count\030\014 \001(\005\032(\n\005Cr"
|
|
"ash\022\016\n\006reason\030\001 \002(\t\022\017\n\007address\030\002 \002(\003\0325\n\006"
|
|
"Thread\022+\n\006frames\030\001 \003(\0132\033.google_breakpad"
|
|
".StackFrame\"\305\001\n\nStackFrame\022\023\n\013instructio"
|
|
"n\030\001 \002(\003\022+\n\006module\030\002 \001(\0132\033.google_breakpa"
|
|
"d.CodeModule\022\025\n\rfunction_name\030\003 \001(\t\022\025\n\rf"
|
|
"unction_base\030\004 \001(\003\022\030\n\020source_file_name\030\005"
|
|
" \001(\t\022\023\n\013source_line\030\006 \001(\005\022\030\n\020source_line"
|
|
"_base\030\007 \001(\003\"\233\001\n\nCodeModule\022\024\n\014base_addre"
|
|
"ss\030\001 \001(\003\022\014\n\004size\030\002 \001(\003\022\021\n\tcode_file\030\003 \001("
|
|
"\t\022\027\n\017code_identifier\030\004 \001(\t\022\022\n\ndebug_file"
|
|
"\030\005 \001(\t\022\030\n\020debug_identifier\030\006 \001(\t\022\017\n\007vers"
|
|
"ion\030\007 \001(\t", 849);
|
|
::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
|
|
"process_state.proto", &protobuf_RegisterTypes);
|
|
ProcessStateProto::default_instance_ = new ProcessStateProto();
|
|
ProcessStateProto_Crash::default_instance_ = new ProcessStateProto_Crash();
|
|
ProcessStateProto_Thread::default_instance_ = new ProcessStateProto_Thread();
|
|
StackFrame::default_instance_ = new StackFrame();
|
|
CodeModule::default_instance_ = new CodeModule();
|
|
ProcessStateProto::default_instance_->InitAsDefaultInstance();
|
|
ProcessStateProto_Crash::default_instance_->InitAsDefaultInstance();
|
|
ProcessStateProto_Thread::default_instance_->InitAsDefaultInstance();
|
|
StackFrame::default_instance_->InitAsDefaultInstance();
|
|
CodeModule::default_instance_->InitAsDefaultInstance();
|
|
::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_process_5fstate_2eproto);
|
|
}
|
|
|
|
// Force AddDescriptors() to be called at static initialization time.
|
|
struct StaticDescriptorInitializer_process_5fstate_2eproto {
|
|
StaticDescriptorInitializer_process_5fstate_2eproto() {
|
|
protobuf_AddDesc_process_5fstate_2eproto();
|
|
}
|
|
} static_descriptor_initializer_process_5fstate_2eproto_;
|
|
|
|
|
|
// ===================================================================
|
|
|
|
const ::std::string ProcessStateProto_Crash::_default_reason_;
|
|
#ifndef _MSC_VER
|
|
const int ProcessStateProto_Crash::kReasonFieldNumber;
|
|
const int ProcessStateProto_Crash::kAddressFieldNumber;
|
|
#endif // !_MSC_VER
|
|
|
|
ProcessStateProto_Crash::ProcessStateProto_Crash()
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
}
|
|
|
|
void ProcessStateProto_Crash::InitAsDefaultInstance() {
|
|
}
|
|
|
|
ProcessStateProto_Crash::ProcessStateProto_Crash(const ProcessStateProto_Crash& from)
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void ProcessStateProto_Crash::SharedCtor() {
|
|
_cached_size_ = 0;
|
|
reason_ = const_cast< ::std::string*>(&_default_reason_);
|
|
address_ = GOOGLE_LONGLONG(0);
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
}
|
|
|
|
ProcessStateProto_Crash::~ProcessStateProto_Crash() {
|
|
SharedDtor();
|
|
}
|
|
|
|
void ProcessStateProto_Crash::SharedDtor() {
|
|
if (reason_ != &_default_reason_) {
|
|
delete reason_;
|
|
}
|
|
if (this != default_instance_) {
|
|
}
|
|
}
|
|
|
|
void ProcessStateProto_Crash::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const ::google::protobuf::Descriptor* ProcessStateProto_Crash::descriptor() {
|
|
protobuf_AssignDescriptorsOnce();
|
|
return ProcessStateProto_Crash_descriptor_;
|
|
}
|
|
|
|
const ProcessStateProto_Crash& ProcessStateProto_Crash::default_instance() {
|
|
if (default_instance_ == NULL) protobuf_AddDesc_process_5fstate_2eproto(); return *default_instance_;
|
|
}
|
|
|
|
ProcessStateProto_Crash* ProcessStateProto_Crash::default_instance_ = NULL;
|
|
|
|
ProcessStateProto_Crash* ProcessStateProto_Crash::New() const {
|
|
return new ProcessStateProto_Crash;
|
|
}
|
|
|
|
void ProcessStateProto_Crash::Clear() {
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
if (_has_bit(0)) {
|
|
if (reason_ != &_default_reason_) {
|
|
reason_->clear();
|
|
}
|
|
}
|
|
address_ = GOOGLE_LONGLONG(0);
|
|
}
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
mutable_unknown_fields()->Clear();
|
|
}
|
|
|
|
bool ProcessStateProto_Crash::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
|
|
::google::protobuf::uint32 tag;
|
|
while ((tag = input->ReadTag()) != 0) {
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// required string reason = 1;
|
|
case 1: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_reason()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->reason().data(), this->reason().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(16)) goto parse_address;
|
|
break;
|
|
}
|
|
|
|
// required int64 address = 2;
|
|
case 2: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
|
|
parse_address:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
|
|
input, &address_)));
|
|
_set_bit(1);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectAtEnd()) return true;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_uninterpreted:
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
return true;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormat::SkipField(
|
|
input, tag, mutable_unknown_fields()));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
#undef DO_
|
|
}
|
|
|
|
void ProcessStateProto_Crash::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// required string reason = 1;
|
|
if (_has_bit(0)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->reason().data(), this->reason().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
1, this->reason(), output);
|
|
}
|
|
|
|
// required int64 address = 2;
|
|
if (_has_bit(1)) {
|
|
::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->address(), output);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
|
|
unknown_fields(), output);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::uint8* ProcessStateProto_Crash::SerializeWithCachedSizesToArray(
|
|
::google::protobuf::uint8* target) const {
|
|
// required string reason = 1;
|
|
if (_has_bit(0)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->reason().data(), this->reason().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
1, this->reason(), target);
|
|
}
|
|
|
|
// required int64 address = 2;
|
|
if (_has_bit(1)) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->address(), target);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
|
|
unknown_fields(), target);
|
|
}
|
|
return target;
|
|
}
|
|
|
|
int ProcessStateProto_Crash::ByteSize() const {
|
|
int total_size = 0;
|
|
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
// required string reason = 1;
|
|
if (has_reason()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->reason());
|
|
}
|
|
|
|
// required int64 address = 2;
|
|
if (has_address()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int64Size(
|
|
this->address());
|
|
}
|
|
|
|
}
|
|
if (!unknown_fields().empty()) {
|
|
total_size +=
|
|
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
|
|
unknown_fields());
|
|
}
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = total_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void ProcessStateProto_Crash::MergeFrom(const ::google::protobuf::Message& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
const ProcessStateProto_Crash* source =
|
|
::google::protobuf::internal::dynamic_cast_if_available<const ProcessStateProto_Crash*>(
|
|
&from);
|
|
if (source == NULL) {
|
|
::google::protobuf::internal::ReflectionOps::Merge(from, this);
|
|
} else {
|
|
MergeFrom(*source);
|
|
}
|
|
}
|
|
|
|
void ProcessStateProto_Crash::MergeFrom(const ProcessStateProto_Crash& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
if (from._has_bit(0)) {
|
|
set_reason(from.reason());
|
|
}
|
|
if (from._has_bit(1)) {
|
|
set_address(from.address());
|
|
}
|
|
}
|
|
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
|
|
}
|
|
|
|
void ProcessStateProto_Crash::CopyFrom(const ::google::protobuf::Message& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void ProcessStateProto_Crash::CopyFrom(const ProcessStateProto_Crash& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool ProcessStateProto_Crash::IsInitialized() const {
|
|
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void ProcessStateProto_Crash::Swap(ProcessStateProto_Crash* other) {
|
|
if (other != this) {
|
|
std::swap(reason_, other->reason_);
|
|
std::swap(address_, other->address_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_unknown_fields_.Swap(&other->_unknown_fields_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::Metadata ProcessStateProto_Crash::GetMetadata() const {
|
|
protobuf_AssignDescriptorsOnce();
|
|
::google::protobuf::Metadata metadata;
|
|
metadata.descriptor = ProcessStateProto_Crash_descriptor_;
|
|
metadata.reflection = ProcessStateProto_Crash_reflection_;
|
|
return metadata;
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
#ifndef _MSC_VER
|
|
const int ProcessStateProto_Thread::kFramesFieldNumber;
|
|
#endif // !_MSC_VER
|
|
|
|
ProcessStateProto_Thread::ProcessStateProto_Thread()
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
}
|
|
|
|
void ProcessStateProto_Thread::InitAsDefaultInstance() {
|
|
}
|
|
|
|
ProcessStateProto_Thread::ProcessStateProto_Thread(const ProcessStateProto_Thread& from)
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void ProcessStateProto_Thread::SharedCtor() {
|
|
_cached_size_ = 0;
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
}
|
|
|
|
ProcessStateProto_Thread::~ProcessStateProto_Thread() {
|
|
SharedDtor();
|
|
}
|
|
|
|
void ProcessStateProto_Thread::SharedDtor() {
|
|
if (this != default_instance_) {
|
|
}
|
|
}
|
|
|
|
void ProcessStateProto_Thread::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const ::google::protobuf::Descriptor* ProcessStateProto_Thread::descriptor() {
|
|
protobuf_AssignDescriptorsOnce();
|
|
return ProcessStateProto_Thread_descriptor_;
|
|
}
|
|
|
|
const ProcessStateProto_Thread& ProcessStateProto_Thread::default_instance() {
|
|
if (default_instance_ == NULL) protobuf_AddDesc_process_5fstate_2eproto(); return *default_instance_;
|
|
}
|
|
|
|
ProcessStateProto_Thread* ProcessStateProto_Thread::default_instance_ = NULL;
|
|
|
|
ProcessStateProto_Thread* ProcessStateProto_Thread::New() const {
|
|
return new ProcessStateProto_Thread;
|
|
}
|
|
|
|
void ProcessStateProto_Thread::Clear() {
|
|
frames_.Clear();
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
mutable_unknown_fields()->Clear();
|
|
}
|
|
|
|
bool ProcessStateProto_Thread::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
|
|
::google::protobuf::uint32 tag;
|
|
while ((tag = input->ReadTag()) != 0) {
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// repeated .google_breakpad.StackFrame frames = 1;
|
|
case 1: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_frames:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
|
|
input, add_frames()));
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(10)) goto parse_frames;
|
|
if (input->ExpectAtEnd()) return true;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_uninterpreted:
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
return true;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormat::SkipField(
|
|
input, tag, mutable_unknown_fields()));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
#undef DO_
|
|
}
|
|
|
|
void ProcessStateProto_Thread::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// repeated .google_breakpad.StackFrame frames = 1;
|
|
for (int i = 0; i < this->frames_size(); i++) {
|
|
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
|
|
1, this->frames(i), output);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
|
|
unknown_fields(), output);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::uint8* ProcessStateProto_Thread::SerializeWithCachedSizesToArray(
|
|
::google::protobuf::uint8* target) const {
|
|
// repeated .google_breakpad.StackFrame frames = 1;
|
|
for (int i = 0; i < this->frames_size(); i++) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteMessageNoVirtualToArray(
|
|
1, this->frames(i), target);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
|
|
unknown_fields(), target);
|
|
}
|
|
return target;
|
|
}
|
|
|
|
int ProcessStateProto_Thread::ByteSize() const {
|
|
int total_size = 0;
|
|
|
|
// repeated .google_breakpad.StackFrame frames = 1;
|
|
total_size += 1 * this->frames_size();
|
|
for (int i = 0; i < this->frames_size(); i++) {
|
|
total_size +=
|
|
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
|
|
this->frames(i));
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
total_size +=
|
|
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
|
|
unknown_fields());
|
|
}
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = total_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void ProcessStateProto_Thread::MergeFrom(const ::google::protobuf::Message& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
const ProcessStateProto_Thread* source =
|
|
::google::protobuf::internal::dynamic_cast_if_available<const ProcessStateProto_Thread*>(
|
|
&from);
|
|
if (source == NULL) {
|
|
::google::protobuf::internal::ReflectionOps::Merge(from, this);
|
|
} else {
|
|
MergeFrom(*source);
|
|
}
|
|
}
|
|
|
|
void ProcessStateProto_Thread::MergeFrom(const ProcessStateProto_Thread& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
frames_.MergeFrom(from.frames_);
|
|
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
|
|
}
|
|
|
|
void ProcessStateProto_Thread::CopyFrom(const ::google::protobuf::Message& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void ProcessStateProto_Thread::CopyFrom(const ProcessStateProto_Thread& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool ProcessStateProto_Thread::IsInitialized() const {
|
|
|
|
for (int i = 0; i < frames_size(); i++) {
|
|
if (!this->frames(i).IsInitialized()) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void ProcessStateProto_Thread::Swap(ProcessStateProto_Thread* other) {
|
|
if (other != this) {
|
|
frames_.Swap(&other->frames_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_unknown_fields_.Swap(&other->_unknown_fields_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::Metadata ProcessStateProto_Thread::GetMetadata() const {
|
|
protobuf_AssignDescriptorsOnce();
|
|
::google::protobuf::Metadata metadata;
|
|
metadata.descriptor = ProcessStateProto_Thread_descriptor_;
|
|
metadata.reflection = ProcessStateProto_Thread_reflection_;
|
|
return metadata;
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
const ::std::string ProcessStateProto::_default_assertion_;
|
|
const ::std::string ProcessStateProto::_default_os_;
|
|
const ::std::string ProcessStateProto::_default_os_short_;
|
|
const ::std::string ProcessStateProto::_default_os_version_;
|
|
const ::std::string ProcessStateProto::_default_cpu_;
|
|
const ::std::string ProcessStateProto::_default_cpu_info_;
|
|
#ifndef _MSC_VER
|
|
const int ProcessStateProto::kTimeDateStampFieldNumber;
|
|
const int ProcessStateProto::kCrashFieldNumber;
|
|
const int ProcessStateProto::kAssertionFieldNumber;
|
|
const int ProcessStateProto::kRequestingThreadFieldNumber;
|
|
const int ProcessStateProto::kThreadsFieldNumber;
|
|
const int ProcessStateProto::kModulesFieldNumber;
|
|
const int ProcessStateProto::kOsFieldNumber;
|
|
const int ProcessStateProto::kOsShortFieldNumber;
|
|
const int ProcessStateProto::kOsVersionFieldNumber;
|
|
const int ProcessStateProto::kCpuFieldNumber;
|
|
const int ProcessStateProto::kCpuInfoFieldNumber;
|
|
const int ProcessStateProto::kCpuCountFieldNumber;
|
|
#endif // !_MSC_VER
|
|
|
|
ProcessStateProto::ProcessStateProto()
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
}
|
|
|
|
void ProcessStateProto::InitAsDefaultInstance() {
|
|
crash_ = const_cast< ::google_breakpad::ProcessStateProto_Crash*>(&::google_breakpad::ProcessStateProto_Crash::default_instance());
|
|
}
|
|
|
|
ProcessStateProto::ProcessStateProto(const ProcessStateProto& from)
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void ProcessStateProto::SharedCtor() {
|
|
_cached_size_ = 0;
|
|
time_date_stamp_ = GOOGLE_LONGLONG(0);
|
|
crash_ = NULL;
|
|
assertion_ = const_cast< ::std::string*>(&_default_assertion_);
|
|
requesting_thread_ = 0;
|
|
os_ = const_cast< ::std::string*>(&_default_os_);
|
|
os_short_ = const_cast< ::std::string*>(&_default_os_short_);
|
|
os_version_ = const_cast< ::std::string*>(&_default_os_version_);
|
|
cpu_ = const_cast< ::std::string*>(&_default_cpu_);
|
|
cpu_info_ = const_cast< ::std::string*>(&_default_cpu_info_);
|
|
cpu_count_ = 0;
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
}
|
|
|
|
ProcessStateProto::~ProcessStateProto() {
|
|
SharedDtor();
|
|
}
|
|
|
|
void ProcessStateProto::SharedDtor() {
|
|
if (assertion_ != &_default_assertion_) {
|
|
delete assertion_;
|
|
}
|
|
if (os_ != &_default_os_) {
|
|
delete os_;
|
|
}
|
|
if (os_short_ != &_default_os_short_) {
|
|
delete os_short_;
|
|
}
|
|
if (os_version_ != &_default_os_version_) {
|
|
delete os_version_;
|
|
}
|
|
if (cpu_ != &_default_cpu_) {
|
|
delete cpu_;
|
|
}
|
|
if (cpu_info_ != &_default_cpu_info_) {
|
|
delete cpu_info_;
|
|
}
|
|
if (this != default_instance_) {
|
|
delete crash_;
|
|
}
|
|
}
|
|
|
|
void ProcessStateProto::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const ::google::protobuf::Descriptor* ProcessStateProto::descriptor() {
|
|
protobuf_AssignDescriptorsOnce();
|
|
return ProcessStateProto_descriptor_;
|
|
}
|
|
|
|
const ProcessStateProto& ProcessStateProto::default_instance() {
|
|
if (default_instance_ == NULL) protobuf_AddDesc_process_5fstate_2eproto(); return *default_instance_;
|
|
}
|
|
|
|
ProcessStateProto* ProcessStateProto::default_instance_ = NULL;
|
|
|
|
ProcessStateProto* ProcessStateProto::New() const {
|
|
return new ProcessStateProto;
|
|
}
|
|
|
|
void ProcessStateProto::Clear() {
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
time_date_stamp_ = GOOGLE_LONGLONG(0);
|
|
if (_has_bit(1)) {
|
|
if (crash_ != NULL) crash_->::google_breakpad::ProcessStateProto_Crash::Clear();
|
|
}
|
|
if (_has_bit(2)) {
|
|
if (assertion_ != &_default_assertion_) {
|
|
assertion_->clear();
|
|
}
|
|
}
|
|
requesting_thread_ = 0;
|
|
if (_has_bit(6)) {
|
|
if (os_ != &_default_os_) {
|
|
os_->clear();
|
|
}
|
|
}
|
|
if (_has_bit(7)) {
|
|
if (os_short_ != &_default_os_short_) {
|
|
os_short_->clear();
|
|
}
|
|
}
|
|
}
|
|
if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
|
|
if (_has_bit(8)) {
|
|
if (os_version_ != &_default_os_version_) {
|
|
os_version_->clear();
|
|
}
|
|
}
|
|
if (_has_bit(9)) {
|
|
if (cpu_ != &_default_cpu_) {
|
|
cpu_->clear();
|
|
}
|
|
}
|
|
if (_has_bit(10)) {
|
|
if (cpu_info_ != &_default_cpu_info_) {
|
|
cpu_info_->clear();
|
|
}
|
|
}
|
|
cpu_count_ = 0;
|
|
}
|
|
threads_.Clear();
|
|
modules_.Clear();
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
mutable_unknown_fields()->Clear();
|
|
}
|
|
|
|
bool ProcessStateProto::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
|
|
::google::protobuf::uint32 tag;
|
|
while ((tag = input->ReadTag()) != 0) {
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// optional int64 time_date_stamp = 1;
|
|
case 1: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
|
|
input, &time_date_stamp_)));
|
|
_set_bit(0);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(18)) goto parse_crash;
|
|
break;
|
|
}
|
|
|
|
// optional .google_breakpad.ProcessStateProto.Crash crash = 2;
|
|
case 2: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_crash:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
|
|
input, mutable_crash()));
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(26)) goto parse_assertion;
|
|
break;
|
|
}
|
|
|
|
// optional string assertion = 3;
|
|
case 3: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_assertion:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_assertion()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->assertion().data(), this->assertion().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(32)) goto parse_requesting_thread;
|
|
break;
|
|
}
|
|
|
|
// optional int32 requesting_thread = 4;
|
|
case 4: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
|
|
parse_requesting_thread:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
|
|
input, &requesting_thread_)));
|
|
_set_bit(3);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(42)) goto parse_threads;
|
|
break;
|
|
}
|
|
|
|
// repeated .google_breakpad.ProcessStateProto.Thread threads = 5;
|
|
case 5: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_threads:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
|
|
input, add_threads()));
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(42)) goto parse_threads;
|
|
if (input->ExpectTag(50)) goto parse_modules;
|
|
break;
|
|
}
|
|
|
|
// repeated .google_breakpad.CodeModule modules = 6;
|
|
case 6: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_modules:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
|
|
input, add_modules()));
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(50)) goto parse_modules;
|
|
if (input->ExpectTag(58)) goto parse_os;
|
|
break;
|
|
}
|
|
|
|
// optional string os = 7;
|
|
case 7: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_os:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_os()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->os().data(), this->os().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(66)) goto parse_os_short;
|
|
break;
|
|
}
|
|
|
|
// optional string os_short = 8;
|
|
case 8: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_os_short:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_os_short()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->os_short().data(), this->os_short().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(74)) goto parse_os_version;
|
|
break;
|
|
}
|
|
|
|
// optional string os_version = 9;
|
|
case 9: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_os_version:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_os_version()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->os_version().data(), this->os_version().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(82)) goto parse_cpu;
|
|
break;
|
|
}
|
|
|
|
// optional string cpu = 10;
|
|
case 10: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_cpu:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_cpu()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->cpu().data(), this->cpu().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(90)) goto parse_cpu_info;
|
|
break;
|
|
}
|
|
|
|
// optional string cpu_info = 11;
|
|
case 11: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_cpu_info:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_cpu_info()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->cpu_info().data(), this->cpu_info().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(96)) goto parse_cpu_count;
|
|
break;
|
|
}
|
|
|
|
// optional int32 cpu_count = 12;
|
|
case 12: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
|
|
parse_cpu_count:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
|
|
input, &cpu_count_)));
|
|
_set_bit(11);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectAtEnd()) return true;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_uninterpreted:
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
return true;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormat::SkipField(
|
|
input, tag, mutable_unknown_fields()));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
#undef DO_
|
|
}
|
|
|
|
void ProcessStateProto::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// optional int64 time_date_stamp = 1;
|
|
if (_has_bit(0)) {
|
|
::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->time_date_stamp(), output);
|
|
}
|
|
|
|
// optional .google_breakpad.ProcessStateProto.Crash crash = 2;
|
|
if (_has_bit(1)) {
|
|
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
|
|
2, this->crash(), output);
|
|
}
|
|
|
|
// optional string assertion = 3;
|
|
if (_has_bit(2)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->assertion().data(), this->assertion().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
3, this->assertion(), output);
|
|
}
|
|
|
|
// optional int32 requesting_thread = 4;
|
|
if (_has_bit(3)) {
|
|
::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->requesting_thread(), output);
|
|
}
|
|
|
|
// repeated .google_breakpad.ProcessStateProto.Thread threads = 5;
|
|
for (int i = 0; i < this->threads_size(); i++) {
|
|
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
|
|
5, this->threads(i), output);
|
|
}
|
|
|
|
// repeated .google_breakpad.CodeModule modules = 6;
|
|
for (int i = 0; i < this->modules_size(); i++) {
|
|
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
|
|
6, this->modules(i), output);
|
|
}
|
|
|
|
// optional string os = 7;
|
|
if (_has_bit(6)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->os().data(), this->os().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
7, this->os(), output);
|
|
}
|
|
|
|
// optional string os_short = 8;
|
|
if (_has_bit(7)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->os_short().data(), this->os_short().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
8, this->os_short(), output);
|
|
}
|
|
|
|
// optional string os_version = 9;
|
|
if (_has_bit(8)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->os_version().data(), this->os_version().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
9, this->os_version(), output);
|
|
}
|
|
|
|
// optional string cpu = 10;
|
|
if (_has_bit(9)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->cpu().data(), this->cpu().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
10, this->cpu(), output);
|
|
}
|
|
|
|
// optional string cpu_info = 11;
|
|
if (_has_bit(10)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->cpu_info().data(), this->cpu_info().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
11, this->cpu_info(), output);
|
|
}
|
|
|
|
// optional int32 cpu_count = 12;
|
|
if (_has_bit(11)) {
|
|
::google::protobuf::internal::WireFormatLite::WriteInt32(12, this->cpu_count(), output);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
|
|
unknown_fields(), output);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::uint8* ProcessStateProto::SerializeWithCachedSizesToArray(
|
|
::google::protobuf::uint8* target) const {
|
|
// optional int64 time_date_stamp = 1;
|
|
if (_has_bit(0)) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->time_date_stamp(), target);
|
|
}
|
|
|
|
// optional .google_breakpad.ProcessStateProto.Crash crash = 2;
|
|
if (_has_bit(1)) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteMessageNoVirtualToArray(
|
|
2, this->crash(), target);
|
|
}
|
|
|
|
// optional string assertion = 3;
|
|
if (_has_bit(2)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->assertion().data(), this->assertion().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
3, this->assertion(), target);
|
|
}
|
|
|
|
// optional int32 requesting_thread = 4;
|
|
if (_has_bit(3)) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->requesting_thread(), target);
|
|
}
|
|
|
|
// repeated .google_breakpad.ProcessStateProto.Thread threads = 5;
|
|
for (int i = 0; i < this->threads_size(); i++) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteMessageNoVirtualToArray(
|
|
5, this->threads(i), target);
|
|
}
|
|
|
|
// repeated .google_breakpad.CodeModule modules = 6;
|
|
for (int i = 0; i < this->modules_size(); i++) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteMessageNoVirtualToArray(
|
|
6, this->modules(i), target);
|
|
}
|
|
|
|
// optional string os = 7;
|
|
if (_has_bit(6)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->os().data(), this->os().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
7, this->os(), target);
|
|
}
|
|
|
|
// optional string os_short = 8;
|
|
if (_has_bit(7)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->os_short().data(), this->os_short().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
8, this->os_short(), target);
|
|
}
|
|
|
|
// optional string os_version = 9;
|
|
if (_has_bit(8)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->os_version().data(), this->os_version().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
9, this->os_version(), target);
|
|
}
|
|
|
|
// optional string cpu = 10;
|
|
if (_has_bit(9)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->cpu().data(), this->cpu().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
10, this->cpu(), target);
|
|
}
|
|
|
|
// optional string cpu_info = 11;
|
|
if (_has_bit(10)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->cpu_info().data(), this->cpu_info().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
11, this->cpu_info(), target);
|
|
}
|
|
|
|
// optional int32 cpu_count = 12;
|
|
if (_has_bit(11)) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(12, this->cpu_count(), target);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
|
|
unknown_fields(), target);
|
|
}
|
|
return target;
|
|
}
|
|
|
|
int ProcessStateProto::ByteSize() const {
|
|
int total_size = 0;
|
|
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
// optional int64 time_date_stamp = 1;
|
|
if (has_time_date_stamp()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int64Size(
|
|
this->time_date_stamp());
|
|
}
|
|
|
|
// optional .google_breakpad.ProcessStateProto.Crash crash = 2;
|
|
if (has_crash()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
|
|
this->crash());
|
|
}
|
|
|
|
// optional string assertion = 3;
|
|
if (has_assertion()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->assertion());
|
|
}
|
|
|
|
// optional int32 requesting_thread = 4;
|
|
if (has_requesting_thread()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int32Size(
|
|
this->requesting_thread());
|
|
}
|
|
|
|
// optional string os = 7;
|
|
if (has_os()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->os());
|
|
}
|
|
|
|
// optional string os_short = 8;
|
|
if (has_os_short()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->os_short());
|
|
}
|
|
|
|
}
|
|
if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
|
|
// optional string os_version = 9;
|
|
if (has_os_version()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->os_version());
|
|
}
|
|
|
|
// optional string cpu = 10;
|
|
if (has_cpu()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->cpu());
|
|
}
|
|
|
|
// optional string cpu_info = 11;
|
|
if (has_cpu_info()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->cpu_info());
|
|
}
|
|
|
|
// optional int32 cpu_count = 12;
|
|
if (has_cpu_count()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int32Size(
|
|
this->cpu_count());
|
|
}
|
|
|
|
}
|
|
// repeated .google_breakpad.ProcessStateProto.Thread threads = 5;
|
|
total_size += 1 * this->threads_size();
|
|
for (int i = 0; i < this->threads_size(); i++) {
|
|
total_size +=
|
|
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
|
|
this->threads(i));
|
|
}
|
|
|
|
// repeated .google_breakpad.CodeModule modules = 6;
|
|
total_size += 1 * this->modules_size();
|
|
for (int i = 0; i < this->modules_size(); i++) {
|
|
total_size +=
|
|
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
|
|
this->modules(i));
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
total_size +=
|
|
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
|
|
unknown_fields());
|
|
}
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = total_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void ProcessStateProto::MergeFrom(const ::google::protobuf::Message& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
const ProcessStateProto* source =
|
|
::google::protobuf::internal::dynamic_cast_if_available<const ProcessStateProto*>(
|
|
&from);
|
|
if (source == NULL) {
|
|
::google::protobuf::internal::ReflectionOps::Merge(from, this);
|
|
} else {
|
|
MergeFrom(*source);
|
|
}
|
|
}
|
|
|
|
void ProcessStateProto::MergeFrom(const ProcessStateProto& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
threads_.MergeFrom(from.threads_);
|
|
modules_.MergeFrom(from.modules_);
|
|
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
if (from._has_bit(0)) {
|
|
set_time_date_stamp(from.time_date_stamp());
|
|
}
|
|
if (from._has_bit(1)) {
|
|
mutable_crash()->::google_breakpad::ProcessStateProto_Crash::MergeFrom(from.crash());
|
|
}
|
|
if (from._has_bit(2)) {
|
|
set_assertion(from.assertion());
|
|
}
|
|
if (from._has_bit(3)) {
|
|
set_requesting_thread(from.requesting_thread());
|
|
}
|
|
if (from._has_bit(6)) {
|
|
set_os(from.os());
|
|
}
|
|
if (from._has_bit(7)) {
|
|
set_os_short(from.os_short());
|
|
}
|
|
}
|
|
if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
|
|
if (from._has_bit(8)) {
|
|
set_os_version(from.os_version());
|
|
}
|
|
if (from._has_bit(9)) {
|
|
set_cpu(from.cpu());
|
|
}
|
|
if (from._has_bit(10)) {
|
|
set_cpu_info(from.cpu_info());
|
|
}
|
|
if (from._has_bit(11)) {
|
|
set_cpu_count(from.cpu_count());
|
|
}
|
|
}
|
|
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
|
|
}
|
|
|
|
void ProcessStateProto::CopyFrom(const ::google::protobuf::Message& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void ProcessStateProto::CopyFrom(const ProcessStateProto& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool ProcessStateProto::IsInitialized() const {
|
|
|
|
if (has_crash()) {
|
|
if (!this->crash().IsInitialized()) return false;
|
|
}
|
|
for (int i = 0; i < threads_size(); i++) {
|
|
if (!this->threads(i).IsInitialized()) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void ProcessStateProto::Swap(ProcessStateProto* other) {
|
|
if (other != this) {
|
|
std::swap(time_date_stamp_, other->time_date_stamp_);
|
|
std::swap(crash_, other->crash_);
|
|
std::swap(assertion_, other->assertion_);
|
|
std::swap(requesting_thread_, other->requesting_thread_);
|
|
threads_.Swap(&other->threads_);
|
|
modules_.Swap(&other->modules_);
|
|
std::swap(os_, other->os_);
|
|
std::swap(os_short_, other->os_short_);
|
|
std::swap(os_version_, other->os_version_);
|
|
std::swap(cpu_, other->cpu_);
|
|
std::swap(cpu_info_, other->cpu_info_);
|
|
std::swap(cpu_count_, other->cpu_count_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_unknown_fields_.Swap(&other->_unknown_fields_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::Metadata ProcessStateProto::GetMetadata() const {
|
|
protobuf_AssignDescriptorsOnce();
|
|
::google::protobuf::Metadata metadata;
|
|
metadata.descriptor = ProcessStateProto_descriptor_;
|
|
metadata.reflection = ProcessStateProto_reflection_;
|
|
return metadata;
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
const ::std::string StackFrame::_default_function_name_;
|
|
const ::std::string StackFrame::_default_source_file_name_;
|
|
#ifndef _MSC_VER
|
|
const int StackFrame::kInstructionFieldNumber;
|
|
const int StackFrame::kModuleFieldNumber;
|
|
const int StackFrame::kFunctionNameFieldNumber;
|
|
const int StackFrame::kFunctionBaseFieldNumber;
|
|
const int StackFrame::kSourceFileNameFieldNumber;
|
|
const int StackFrame::kSourceLineFieldNumber;
|
|
const int StackFrame::kSourceLineBaseFieldNumber;
|
|
#endif // !_MSC_VER
|
|
|
|
StackFrame::StackFrame()
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
}
|
|
|
|
void StackFrame::InitAsDefaultInstance() {
|
|
module_ = const_cast< ::google_breakpad::CodeModule*>(&::google_breakpad::CodeModule::default_instance());
|
|
}
|
|
|
|
StackFrame::StackFrame(const StackFrame& from)
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void StackFrame::SharedCtor() {
|
|
_cached_size_ = 0;
|
|
instruction_ = GOOGLE_LONGLONG(0);
|
|
module_ = NULL;
|
|
function_name_ = const_cast< ::std::string*>(&_default_function_name_);
|
|
function_base_ = GOOGLE_LONGLONG(0);
|
|
source_file_name_ = const_cast< ::std::string*>(&_default_source_file_name_);
|
|
source_line_ = 0;
|
|
source_line_base_ = GOOGLE_LONGLONG(0);
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
}
|
|
|
|
StackFrame::~StackFrame() {
|
|
SharedDtor();
|
|
}
|
|
|
|
void StackFrame::SharedDtor() {
|
|
if (function_name_ != &_default_function_name_) {
|
|
delete function_name_;
|
|
}
|
|
if (source_file_name_ != &_default_source_file_name_) {
|
|
delete source_file_name_;
|
|
}
|
|
if (this != default_instance_) {
|
|
delete module_;
|
|
}
|
|
}
|
|
|
|
void StackFrame::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const ::google::protobuf::Descriptor* StackFrame::descriptor() {
|
|
protobuf_AssignDescriptorsOnce();
|
|
return StackFrame_descriptor_;
|
|
}
|
|
|
|
const StackFrame& StackFrame::default_instance() {
|
|
if (default_instance_ == NULL) protobuf_AddDesc_process_5fstate_2eproto(); return *default_instance_;
|
|
}
|
|
|
|
StackFrame* StackFrame::default_instance_ = NULL;
|
|
|
|
StackFrame* StackFrame::New() const {
|
|
return new StackFrame;
|
|
}
|
|
|
|
void StackFrame::Clear() {
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
instruction_ = GOOGLE_LONGLONG(0);
|
|
if (_has_bit(1)) {
|
|
if (module_ != NULL) module_->::google_breakpad::CodeModule::Clear();
|
|
}
|
|
if (_has_bit(2)) {
|
|
if (function_name_ != &_default_function_name_) {
|
|
function_name_->clear();
|
|
}
|
|
}
|
|
function_base_ = GOOGLE_LONGLONG(0);
|
|
if (_has_bit(4)) {
|
|
if (source_file_name_ != &_default_source_file_name_) {
|
|
source_file_name_->clear();
|
|
}
|
|
}
|
|
source_line_ = 0;
|
|
source_line_base_ = GOOGLE_LONGLONG(0);
|
|
}
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
mutable_unknown_fields()->Clear();
|
|
}
|
|
|
|
bool StackFrame::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
|
|
::google::protobuf::uint32 tag;
|
|
while ((tag = input->ReadTag()) != 0) {
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// required int64 instruction = 1;
|
|
case 1: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
|
|
input, &instruction_)));
|
|
_set_bit(0);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(18)) goto parse_module;
|
|
break;
|
|
}
|
|
|
|
// optional .google_breakpad.CodeModule module = 2;
|
|
case 2: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_module:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
|
|
input, mutable_module()));
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(26)) goto parse_function_name;
|
|
break;
|
|
}
|
|
|
|
// optional string function_name = 3;
|
|
case 3: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_function_name:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_function_name()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->function_name().data(), this->function_name().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(32)) goto parse_function_base;
|
|
break;
|
|
}
|
|
|
|
// optional int64 function_base = 4;
|
|
case 4: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
|
|
parse_function_base:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
|
|
input, &function_base_)));
|
|
_set_bit(3);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(42)) goto parse_source_file_name;
|
|
break;
|
|
}
|
|
|
|
// optional string source_file_name = 5;
|
|
case 5: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_source_file_name:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_source_file_name()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->source_file_name().data(), this->source_file_name().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(48)) goto parse_source_line;
|
|
break;
|
|
}
|
|
|
|
// optional int32 source_line = 6;
|
|
case 6: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
|
|
parse_source_line:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
|
|
input, &source_line_)));
|
|
_set_bit(5);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(56)) goto parse_source_line_base;
|
|
break;
|
|
}
|
|
|
|
// optional int64 source_line_base = 7;
|
|
case 7: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
|
|
parse_source_line_base:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
|
|
input, &source_line_base_)));
|
|
_set_bit(6);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectAtEnd()) return true;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_uninterpreted:
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
return true;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormat::SkipField(
|
|
input, tag, mutable_unknown_fields()));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
#undef DO_
|
|
}
|
|
|
|
void StackFrame::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// required int64 instruction = 1;
|
|
if (_has_bit(0)) {
|
|
::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->instruction(), output);
|
|
}
|
|
|
|
// optional .google_breakpad.CodeModule module = 2;
|
|
if (_has_bit(1)) {
|
|
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
|
|
2, this->module(), output);
|
|
}
|
|
|
|
// optional string function_name = 3;
|
|
if (_has_bit(2)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->function_name().data(), this->function_name().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
3, this->function_name(), output);
|
|
}
|
|
|
|
// optional int64 function_base = 4;
|
|
if (_has_bit(3)) {
|
|
::google::protobuf::internal::WireFormatLite::WriteInt64(4, this->function_base(), output);
|
|
}
|
|
|
|
// optional string source_file_name = 5;
|
|
if (_has_bit(4)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->source_file_name().data(), this->source_file_name().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
5, this->source_file_name(), output);
|
|
}
|
|
|
|
// optional int32 source_line = 6;
|
|
if (_has_bit(5)) {
|
|
::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->source_line(), output);
|
|
}
|
|
|
|
// optional int64 source_line_base = 7;
|
|
if (_has_bit(6)) {
|
|
::google::protobuf::internal::WireFormatLite::WriteInt64(7, this->source_line_base(), output);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
|
|
unknown_fields(), output);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::uint8* StackFrame::SerializeWithCachedSizesToArray(
|
|
::google::protobuf::uint8* target) const {
|
|
// required int64 instruction = 1;
|
|
if (_has_bit(0)) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->instruction(), target);
|
|
}
|
|
|
|
// optional .google_breakpad.CodeModule module = 2;
|
|
if (_has_bit(1)) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteMessageNoVirtualToArray(
|
|
2, this->module(), target);
|
|
}
|
|
|
|
// optional string function_name = 3;
|
|
if (_has_bit(2)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->function_name().data(), this->function_name().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
3, this->function_name(), target);
|
|
}
|
|
|
|
// optional int64 function_base = 4;
|
|
if (_has_bit(3)) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(4, this->function_base(), target);
|
|
}
|
|
|
|
// optional string source_file_name = 5;
|
|
if (_has_bit(4)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->source_file_name().data(), this->source_file_name().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
5, this->source_file_name(), target);
|
|
}
|
|
|
|
// optional int32 source_line = 6;
|
|
if (_has_bit(5)) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->source_line(), target);
|
|
}
|
|
|
|
// optional int64 source_line_base = 7;
|
|
if (_has_bit(6)) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(7, this->source_line_base(), target);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
|
|
unknown_fields(), target);
|
|
}
|
|
return target;
|
|
}
|
|
|
|
int StackFrame::ByteSize() const {
|
|
int total_size = 0;
|
|
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
// required int64 instruction = 1;
|
|
if (has_instruction()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int64Size(
|
|
this->instruction());
|
|
}
|
|
|
|
// optional .google_breakpad.CodeModule module = 2;
|
|
if (has_module()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
|
|
this->module());
|
|
}
|
|
|
|
// optional string function_name = 3;
|
|
if (has_function_name()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->function_name());
|
|
}
|
|
|
|
// optional int64 function_base = 4;
|
|
if (has_function_base()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int64Size(
|
|
this->function_base());
|
|
}
|
|
|
|
// optional string source_file_name = 5;
|
|
if (has_source_file_name()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->source_file_name());
|
|
}
|
|
|
|
// optional int32 source_line = 6;
|
|
if (has_source_line()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int32Size(
|
|
this->source_line());
|
|
}
|
|
|
|
// optional int64 source_line_base = 7;
|
|
if (has_source_line_base()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int64Size(
|
|
this->source_line_base());
|
|
}
|
|
|
|
}
|
|
if (!unknown_fields().empty()) {
|
|
total_size +=
|
|
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
|
|
unknown_fields());
|
|
}
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = total_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void StackFrame::MergeFrom(const ::google::protobuf::Message& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
const StackFrame* source =
|
|
::google::protobuf::internal::dynamic_cast_if_available<const StackFrame*>(
|
|
&from);
|
|
if (source == NULL) {
|
|
::google::protobuf::internal::ReflectionOps::Merge(from, this);
|
|
} else {
|
|
MergeFrom(*source);
|
|
}
|
|
}
|
|
|
|
void StackFrame::MergeFrom(const StackFrame& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
if (from._has_bit(0)) {
|
|
set_instruction(from.instruction());
|
|
}
|
|
if (from._has_bit(1)) {
|
|
mutable_module()->::google_breakpad::CodeModule::MergeFrom(from.module());
|
|
}
|
|
if (from._has_bit(2)) {
|
|
set_function_name(from.function_name());
|
|
}
|
|
if (from._has_bit(3)) {
|
|
set_function_base(from.function_base());
|
|
}
|
|
if (from._has_bit(4)) {
|
|
set_source_file_name(from.source_file_name());
|
|
}
|
|
if (from._has_bit(5)) {
|
|
set_source_line(from.source_line());
|
|
}
|
|
if (from._has_bit(6)) {
|
|
set_source_line_base(from.source_line_base());
|
|
}
|
|
}
|
|
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
|
|
}
|
|
|
|
void StackFrame::CopyFrom(const ::google::protobuf::Message& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void StackFrame::CopyFrom(const StackFrame& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool StackFrame::IsInitialized() const {
|
|
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void StackFrame::Swap(StackFrame* other) {
|
|
if (other != this) {
|
|
std::swap(instruction_, other->instruction_);
|
|
std::swap(module_, other->module_);
|
|
std::swap(function_name_, other->function_name_);
|
|
std::swap(function_base_, other->function_base_);
|
|
std::swap(source_file_name_, other->source_file_name_);
|
|
std::swap(source_line_, other->source_line_);
|
|
std::swap(source_line_base_, other->source_line_base_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_unknown_fields_.Swap(&other->_unknown_fields_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::Metadata StackFrame::GetMetadata() const {
|
|
protobuf_AssignDescriptorsOnce();
|
|
::google::protobuf::Metadata metadata;
|
|
metadata.descriptor = StackFrame_descriptor_;
|
|
metadata.reflection = StackFrame_reflection_;
|
|
return metadata;
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
const ::std::string CodeModule::_default_code_file_;
|
|
const ::std::string CodeModule::_default_code_identifier_;
|
|
const ::std::string CodeModule::_default_debug_file_;
|
|
const ::std::string CodeModule::_default_debug_identifier_;
|
|
const ::std::string CodeModule::_default_version_;
|
|
#ifndef _MSC_VER
|
|
const int CodeModule::kBaseAddressFieldNumber;
|
|
const int CodeModule::kSizeFieldNumber;
|
|
const int CodeModule::kCodeFileFieldNumber;
|
|
const int CodeModule::kCodeIdentifierFieldNumber;
|
|
const int CodeModule::kDebugFileFieldNumber;
|
|
const int CodeModule::kDebugIdentifierFieldNumber;
|
|
const int CodeModule::kVersionFieldNumber;
|
|
#endif // !_MSC_VER
|
|
|
|
CodeModule::CodeModule()
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
}
|
|
|
|
void CodeModule::InitAsDefaultInstance() {
|
|
}
|
|
|
|
CodeModule::CodeModule(const CodeModule& from)
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void CodeModule::SharedCtor() {
|
|
_cached_size_ = 0;
|
|
base_address_ = GOOGLE_LONGLONG(0);
|
|
size_ = GOOGLE_LONGLONG(0);
|
|
code_file_ = const_cast< ::std::string*>(&_default_code_file_);
|
|
code_identifier_ = const_cast< ::std::string*>(&_default_code_identifier_);
|
|
debug_file_ = const_cast< ::std::string*>(&_default_debug_file_);
|
|
debug_identifier_ = const_cast< ::std::string*>(&_default_debug_identifier_);
|
|
version_ = const_cast< ::std::string*>(&_default_version_);
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
}
|
|
|
|
CodeModule::~CodeModule() {
|
|
SharedDtor();
|
|
}
|
|
|
|
void CodeModule::SharedDtor() {
|
|
if (code_file_ != &_default_code_file_) {
|
|
delete code_file_;
|
|
}
|
|
if (code_identifier_ != &_default_code_identifier_) {
|
|
delete code_identifier_;
|
|
}
|
|
if (debug_file_ != &_default_debug_file_) {
|
|
delete debug_file_;
|
|
}
|
|
if (debug_identifier_ != &_default_debug_identifier_) {
|
|
delete debug_identifier_;
|
|
}
|
|
if (version_ != &_default_version_) {
|
|
delete version_;
|
|
}
|
|
if (this != default_instance_) {
|
|
}
|
|
}
|
|
|
|
void CodeModule::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const ::google::protobuf::Descriptor* CodeModule::descriptor() {
|
|
protobuf_AssignDescriptorsOnce();
|
|
return CodeModule_descriptor_;
|
|
}
|
|
|
|
const CodeModule& CodeModule::default_instance() {
|
|
if (default_instance_ == NULL) protobuf_AddDesc_process_5fstate_2eproto(); return *default_instance_;
|
|
}
|
|
|
|
CodeModule* CodeModule::default_instance_ = NULL;
|
|
|
|
CodeModule* CodeModule::New() const {
|
|
return new CodeModule;
|
|
}
|
|
|
|
void CodeModule::Clear() {
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
base_address_ = GOOGLE_LONGLONG(0);
|
|
size_ = GOOGLE_LONGLONG(0);
|
|
if (_has_bit(2)) {
|
|
if (code_file_ != &_default_code_file_) {
|
|
code_file_->clear();
|
|
}
|
|
}
|
|
if (_has_bit(3)) {
|
|
if (code_identifier_ != &_default_code_identifier_) {
|
|
code_identifier_->clear();
|
|
}
|
|
}
|
|
if (_has_bit(4)) {
|
|
if (debug_file_ != &_default_debug_file_) {
|
|
debug_file_->clear();
|
|
}
|
|
}
|
|
if (_has_bit(5)) {
|
|
if (debug_identifier_ != &_default_debug_identifier_) {
|
|
debug_identifier_->clear();
|
|
}
|
|
}
|
|
if (_has_bit(6)) {
|
|
if (version_ != &_default_version_) {
|
|
version_->clear();
|
|
}
|
|
}
|
|
}
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
mutable_unknown_fields()->Clear();
|
|
}
|
|
|
|
bool CodeModule::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
|
|
::google::protobuf::uint32 tag;
|
|
while ((tag = input->ReadTag()) != 0) {
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// optional int64 base_address = 1;
|
|
case 1: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
|
|
input, &base_address_)));
|
|
_set_bit(0);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(16)) goto parse_size;
|
|
break;
|
|
}
|
|
|
|
// optional int64 size = 2;
|
|
case 2: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
|
|
parse_size:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
|
|
input, &size_)));
|
|
_set_bit(1);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(26)) goto parse_code_file;
|
|
break;
|
|
}
|
|
|
|
// optional string code_file = 3;
|
|
case 3: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_code_file:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_code_file()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->code_file().data(), this->code_file().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(34)) goto parse_code_identifier;
|
|
break;
|
|
}
|
|
|
|
// optional string code_identifier = 4;
|
|
case 4: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_code_identifier:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_code_identifier()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->code_identifier().data(), this->code_identifier().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(42)) goto parse_debug_file;
|
|
break;
|
|
}
|
|
|
|
// optional string debug_file = 5;
|
|
case 5: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_debug_file:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_debug_file()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->debug_file().data(), this->debug_file().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(50)) goto parse_debug_identifier;
|
|
break;
|
|
}
|
|
|
|
// optional string debug_identifier = 6;
|
|
case 6: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_debug_identifier:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_debug_identifier()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->debug_identifier().data(), this->debug_identifier().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(58)) goto parse_version;
|
|
break;
|
|
}
|
|
|
|
// optional string version = 7;
|
|
case 7: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_version:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_version()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->version().data(), this->version().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectAtEnd()) return true;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_uninterpreted:
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
return true;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormat::SkipField(
|
|
input, tag, mutable_unknown_fields()));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
#undef DO_
|
|
}
|
|
|
|
void CodeModule::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// optional int64 base_address = 1;
|
|
if (_has_bit(0)) {
|
|
::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->base_address(), output);
|
|
}
|
|
|
|
// optional int64 size = 2;
|
|
if (_has_bit(1)) {
|
|
::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->size(), output);
|
|
}
|
|
|
|
// optional string code_file = 3;
|
|
if (_has_bit(2)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->code_file().data(), this->code_file().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
3, this->code_file(), output);
|
|
}
|
|
|
|
// optional string code_identifier = 4;
|
|
if (_has_bit(3)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->code_identifier().data(), this->code_identifier().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
4, this->code_identifier(), output);
|
|
}
|
|
|
|
// optional string debug_file = 5;
|
|
if (_has_bit(4)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->debug_file().data(), this->debug_file().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
5, this->debug_file(), output);
|
|
}
|
|
|
|
// optional string debug_identifier = 6;
|
|
if (_has_bit(5)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->debug_identifier().data(), this->debug_identifier().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
6, this->debug_identifier(), output);
|
|
}
|
|
|
|
// optional string version = 7;
|
|
if (_has_bit(6)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->version().data(), this->version().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
7, this->version(), output);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
|
|
unknown_fields(), output);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::uint8* CodeModule::SerializeWithCachedSizesToArray(
|
|
::google::protobuf::uint8* target) const {
|
|
// optional int64 base_address = 1;
|
|
if (_has_bit(0)) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->base_address(), target);
|
|
}
|
|
|
|
// optional int64 size = 2;
|
|
if (_has_bit(1)) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->size(), target);
|
|
}
|
|
|
|
// optional string code_file = 3;
|
|
if (_has_bit(2)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->code_file().data(), this->code_file().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
3, this->code_file(), target);
|
|
}
|
|
|
|
// optional string code_identifier = 4;
|
|
if (_has_bit(3)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->code_identifier().data(), this->code_identifier().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
4, this->code_identifier(), target);
|
|
}
|
|
|
|
// optional string debug_file = 5;
|
|
if (_has_bit(4)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->debug_file().data(), this->debug_file().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
5, this->debug_file(), target);
|
|
}
|
|
|
|
// optional string debug_identifier = 6;
|
|
if (_has_bit(5)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->debug_identifier().data(), this->debug_identifier().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
6, this->debug_identifier(), target);
|
|
}
|
|
|
|
// optional string version = 7;
|
|
if (_has_bit(6)) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->version().data(), this->version().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
7, this->version(), target);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
|
|
unknown_fields(), target);
|
|
}
|
|
return target;
|
|
}
|
|
|
|
int CodeModule::ByteSize() const {
|
|
int total_size = 0;
|
|
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
// optional int64 base_address = 1;
|
|
if (has_base_address()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int64Size(
|
|
this->base_address());
|
|
}
|
|
|
|
// optional int64 size = 2;
|
|
if (has_size()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int64Size(
|
|
this->size());
|
|
}
|
|
|
|
// optional string code_file = 3;
|
|
if (has_code_file()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->code_file());
|
|
}
|
|
|
|
// optional string code_identifier = 4;
|
|
if (has_code_identifier()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->code_identifier());
|
|
}
|
|
|
|
// optional string debug_file = 5;
|
|
if (has_debug_file()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->debug_file());
|
|
}
|
|
|
|
// optional string debug_identifier = 6;
|
|
if (has_debug_identifier()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->debug_identifier());
|
|
}
|
|
|
|
// optional string version = 7;
|
|
if (has_version()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->version());
|
|
}
|
|
|
|
}
|
|
if (!unknown_fields().empty()) {
|
|
total_size +=
|
|
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
|
|
unknown_fields());
|
|
}
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = total_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void CodeModule::MergeFrom(const ::google::protobuf::Message& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
const CodeModule* source =
|
|
::google::protobuf::internal::dynamic_cast_if_available<const CodeModule*>(
|
|
&from);
|
|
if (source == NULL) {
|
|
::google::protobuf::internal::ReflectionOps::Merge(from, this);
|
|
} else {
|
|
MergeFrom(*source);
|
|
}
|
|
}
|
|
|
|
void CodeModule::MergeFrom(const CodeModule& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
if (from._has_bit(0)) {
|
|
set_base_address(from.base_address());
|
|
}
|
|
if (from._has_bit(1)) {
|
|
set_size(from.size());
|
|
}
|
|
if (from._has_bit(2)) {
|
|
set_code_file(from.code_file());
|
|
}
|
|
if (from._has_bit(3)) {
|
|
set_code_identifier(from.code_identifier());
|
|
}
|
|
if (from._has_bit(4)) {
|
|
set_debug_file(from.debug_file());
|
|
}
|
|
if (from._has_bit(5)) {
|
|
set_debug_identifier(from.debug_identifier());
|
|
}
|
|
if (from._has_bit(6)) {
|
|
set_version(from.version());
|
|
}
|
|
}
|
|
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
|
|
}
|
|
|
|
void CodeModule::CopyFrom(const ::google::protobuf::Message& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void CodeModule::CopyFrom(const CodeModule& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool CodeModule::IsInitialized() const {
|
|
|
|
return true;
|
|
}
|
|
|
|
void CodeModule::Swap(CodeModule* other) {
|
|
if (other != this) {
|
|
std::swap(base_address_, other->base_address_);
|
|
std::swap(size_, other->size_);
|
|
std::swap(code_file_, other->code_file_);
|
|
std::swap(code_identifier_, other->code_identifier_);
|
|
std::swap(debug_file_, other->debug_file_);
|
|
std::swap(debug_identifier_, other->debug_identifier_);
|
|
std::swap(version_, other->version_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_unknown_fields_.Swap(&other->_unknown_fields_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::Metadata CodeModule::GetMetadata() const {
|
|
protobuf_AssignDescriptorsOnce();
|
|
::google::protobuf::Metadata metadata;
|
|
metadata.descriptor = CodeModule_descriptor_;
|
|
metadata.reflection = CodeModule_reflection_;
|
|
return metadata;
|
|
}
|
|
|
|
|
|
// @@protoc_insertion_point(namespace_scope)
|
|
|
|
} // namespace google_breakpad
|
|
|
|
// @@protoc_insertion_point(global_scope)
|