From f8bca185b92f9a8547ad0979b09d4c3119719b59 Mon Sep 17 00:00:00 2001 From: "jessicag.feedback@gmail.com" Date: Tue, 24 Aug 2010 17:32:45 +0000 Subject: Adding process_state protobuf and derived C++ files. Included README as well. git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@663 4c0a9323-5329-0410-9bdc-e9ce6186880e --- src/processor/proto/README | 23 + src/processor/proto/process_state.pb.cc | 2498 +++++++++++++++++++++++++++++++ src/processor/proto/process_state.pb.h | 1644 ++++++++++++++++++++ src/processor/proto/process_state.proto | 204 +++ 4 files changed, 4369 insertions(+) create mode 100644 src/processor/proto/README create mode 100644 src/processor/proto/process_state.pb.cc create mode 100644 src/processor/proto/process_state.pb.h create mode 100644 src/processor/proto/process_state.proto (limited to 'src/processor') diff --git a/src/processor/proto/README b/src/processor/proto/README new file mode 100644 index 00000000..f53f3f0d --- /dev/null +++ b/src/processor/proto/README @@ -0,0 +1,23 @@ +All sourcecode in this file is generated using the .proto and protoc from +the protobuf project (http://code.google.com/p/protobuf/). + +To make changes edit the .proto file and regenerate the dependent files for +check in. + +----- +Troubleshooting for Protobuf: + +Install: +If you are getting permission errors install, make sure you are not trying to +install from an NFS. + + +Running protoc: +protoc: error while loading shared libraries: libprotobuf.so.0: cannot open +shared object file: No such file or directory + +The issue is that Ubuntu 8.04 doesn't include /usr/local/lib in +library paths. + +To fix it for your current terminal session, just type in +export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib diff --git a/src/processor/proto/process_state.pb.cc b/src/processor/proto/process_state.pb.cc new file mode 100644 index 00000000..3a0541e8 --- /dev/null +++ b/src/processor/proto/process_state.pb.cc @@ -0,0 +1,2498 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "process_state.pb.h" +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +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\"\202\003\n\021ProcessStatePr" + "oto\022\027\n\017time_date_stamp\030\001 \001(\003\022\'\n\005crash\030\002 " + "\001(\0132\030.ProcessStateProto.Crash\022\021\n\tasserti" + "on\030\003 \001(\t\022\031\n\021requesting_thread\030\004 \001(\005\022*\n\007t" + "hreads\030\005 \003(\0132\031.ProcessStateProto.Thread\022" + "\034\n\007modules\030\006 \003(\0132\013.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_co" + "unt\030\014 \001(\005\032(\n\005Crash\022\016\n\006reason\030\001 \002(\t\022\017\n\007ad" + "dress\030\002 \002(\003\032%\n\006Thread\022\033\n\006frames\030\001 \003(\0132\013." + "StackFrame\"\265\001\n\nStackFrame\022\023\n\013instruction" + "\030\001 \002(\003\022\033\n\006module\030\002 \001(\0132\013.CodeModule\022\025\n\rf" + "unction_name\030\003 \001(\t\022\025\n\rfunction_base\030\004 \001(" + "\003\022\030\n\020source_file_name\030\005 \001(\t\022\023\n\013source_li" + "ne\030\006 \001(\005\022\030\n\020source_line_base\030\007 \001(\003\"\233\001\n\nC" + "odeModule\022\024\n\014base_address\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_identif" + "ier\030\004 \001(\t\022\022\n\ndebug_file\030\005 \001(\t\022\030\n\020debug_i" + "dentifier\030\006 \001(\t\022\017\n\007version\030\007 \001(\t", 752); + ::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( + &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 .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 .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 .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 .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( + &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< ::ProcessStateProto_Crash*>(&::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_->::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 .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 .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 .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 .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 .ProcessStateProto.Thread threads = 5; + for (int i = 0; i < this->threads_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->threads(i), output); + } + + // repeated .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 .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 .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 .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 .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 .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 .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( + &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()->::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< ::CodeModule*>(&::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_->::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 .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 .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 .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 .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( + &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()->::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( + &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) + +// @@protoc_insertion_point(global_scope) diff --git a/src/processor/proto/process_state.pb.h b/src/processor/proto/process_state.pb.h new file mode 100644 index 00000000..d4b30261 --- /dev/null +++ b/src/processor/proto/process_state.pb.h @@ -0,0 +1,1644 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: process_state.proto + +#ifndef PROTOBUF_process_5fstate_2eproto__INCLUDED +#define PROTOBUF_process_5fstate_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2003000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_process_5fstate_2eproto(); +void protobuf_AssignDesc_process_5fstate_2eproto(); +void protobuf_ShutdownFile_process_5fstate_2eproto(); + +class ProcessStateProto; +class ProcessStateProto_Crash; +class ProcessStateProto_Thread; +class StackFrame; +class CodeModule; + +// =================================================================== + +class ProcessStateProto_Crash : public ::google::protobuf::Message { + public: + ProcessStateProto_Crash(); + virtual ~ProcessStateProto_Crash(); + + ProcessStateProto_Crash(const ProcessStateProto_Crash& from); + + inline ProcessStateProto_Crash& operator=(const ProcessStateProto_Crash& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ProcessStateProto_Crash& default_instance(); + + void Swap(ProcessStateProto_Crash* other); + + // implements Message ---------------------------------------------- + + ProcessStateProto_Crash* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ProcessStateProto_Crash& from); + void MergeFrom(const ProcessStateProto_Crash& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string reason = 1; + inline bool has_reason() const; + inline void clear_reason(); + static const int kReasonFieldNumber = 1; + inline const ::std::string& reason() const; + inline void set_reason(const ::std::string& value); + inline void set_reason(const char* value); + inline void set_reason(const char* value, size_t size); + inline ::std::string* mutable_reason(); + + // required int64 address = 2; + inline bool has_address() const; + inline void clear_address(); + static const int kAddressFieldNumber = 2; + inline ::google::protobuf::int64 address() const; + inline void set_address(::google::protobuf::int64 value); + + // @@protoc_insertion_point(class_scope:ProcessStateProto.Crash) + private: + ::google::protobuf::UnknownFieldSet _unknown_fields_; + mutable int _cached_size_; + + ::std::string* reason_; + static const ::std::string _default_reason_; + ::google::protobuf::int64 address_; + friend void protobuf_AddDesc_process_5fstate_2eproto(); + friend void protobuf_AssignDesc_process_5fstate_2eproto(); + friend void protobuf_ShutdownFile_process_5fstate_2eproto(); + + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? + inline bool _has_bit(int index) const { + return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; + } + inline void _set_bit(int index) { + _has_bits_[index / 32] |= (1u << (index % 32)); + } + inline void _clear_bit(int index) { + _has_bits_[index / 32] &= ~(1u << (index % 32)); + } + + void InitAsDefaultInstance(); + static ProcessStateProto_Crash* default_instance_; +}; +// ------------------------------------------------------------------- + +class ProcessStateProto_Thread : public ::google::protobuf::Message { + public: + ProcessStateProto_Thread(); + virtual ~ProcessStateProto_Thread(); + + ProcessStateProto_Thread(const ProcessStateProto_Thread& from); + + inline ProcessStateProto_Thread& operator=(const ProcessStateProto_Thread& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ProcessStateProto_Thread& default_instance(); + + void Swap(ProcessStateProto_Thread* other); + + // implements Message ---------------------------------------------- + + ProcessStateProto_Thread* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ProcessStateProto_Thread& from); + void MergeFrom(const ProcessStateProto_Thread& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .StackFrame frames = 1; + inline int frames_size() const; + inline void clear_frames(); + static const int kFramesFieldNumber = 1; + inline const ::StackFrame& frames(int index) const; + inline ::StackFrame* mutable_frames(int index); + inline ::StackFrame* add_frames(); + inline const ::google::protobuf::RepeatedPtrField< ::StackFrame >& + frames() const; + inline ::google::protobuf::RepeatedPtrField< ::StackFrame >* + mutable_frames(); + + // @@protoc_insertion_point(class_scope:ProcessStateProto.Thread) + private: + ::google::protobuf::UnknownFieldSet _unknown_fields_; + mutable int _cached_size_; + + ::google::protobuf::RepeatedPtrField< ::StackFrame > frames_; + friend void protobuf_AddDesc_process_5fstate_2eproto(); + friend void protobuf_AssignDesc_process_5fstate_2eproto(); + friend void protobuf_ShutdownFile_process_5fstate_2eproto(); + + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? + inline bool _has_bit(int index) const { + return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; + } + inline void _set_bit(int index) { + _has_bits_[index / 32] |= (1u << (index % 32)); + } + inline void _clear_bit(int index) { + _has_bits_[index / 32] &= ~(1u << (index % 32)); + } + + void InitAsDefaultInstance(); + static ProcessStateProto_Thread* default_instance_; +}; +// ------------------------------------------------------------------- + +class ProcessStateProto : public ::google::protobuf::Message { + public: + ProcessStateProto(); + virtual ~ProcessStateProto(); + + ProcessStateProto(const ProcessStateProto& from); + + inline ProcessStateProto& operator=(const ProcessStateProto& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ProcessStateProto& default_instance(); + + void Swap(ProcessStateProto* other); + + // implements Message ---------------------------------------------- + + ProcessStateProto* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ProcessStateProto& from); + void MergeFrom(const ProcessStateProto& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef ProcessStateProto_Crash Crash; + typedef ProcessStateProto_Thread Thread; + + // accessors ------------------------------------------------------- + + // optional int64 time_date_stamp = 1; + inline bool has_time_date_stamp() const; + inline void clear_time_date_stamp(); + static const int kTimeDateStampFieldNumber = 1; + inline ::google::protobuf::int64 time_date_stamp() const; + inline void set_time_date_stamp(::google::protobuf::int64 value); + + // optional .ProcessStateProto.Crash crash = 2; + inline bool has_crash() const; + inline void clear_crash(); + static const int kCrashFieldNumber = 2; + inline const ::ProcessStateProto_Crash& crash() const; + inline ::ProcessStateProto_Crash* mutable_crash(); + + // optional string assertion = 3; + inline bool has_assertion() const; + inline void clear_assertion(); + static const int kAssertionFieldNumber = 3; + inline const ::std::string& assertion() const; + inline void set_assertion(const ::std::string& value); + inline void set_assertion(const char* value); + inline void set_assertion(const char* value, size_t size); + inline ::std::string* mutable_assertion(); + + // optional int32 requesting_thread = 4; + inline bool has_requesting_thread() const; + inline void clear_requesting_thread(); + static const int kRequestingThreadFieldNumber = 4; + inline ::google::protobuf::int32 requesting_thread() const; + inline void set_requesting_thread(::google::protobuf::int32 value); + + // repeated .ProcessStateProto.Thread threads = 5; + inline int threads_size() const; + inline void clear_threads(); + static const int kThreadsFieldNumber = 5; + inline const ::ProcessStateProto_Thread& threads(int index) const; + inline ::ProcessStateProto_Thread* mutable_threads(int index); + inline ::ProcessStateProto_Thread* add_threads(); + inline const ::google::protobuf::RepeatedPtrField< ::ProcessStateProto_Thread >& + threads() const; + inline ::google::protobuf::RepeatedPtrField< ::ProcessStateProto_Thread >* + mutable_threads(); + + // repeated .CodeModule modules = 6; + inline int modules_size() const; + inline void clear_modules(); + static const int kModulesFieldNumber = 6; + inline const ::CodeModule& modules(int index) const; + inline ::CodeModule* mutable_modules(int index); + inline ::CodeModule* add_modules(); + inline const ::google::protobuf::RepeatedPtrField< ::CodeModule >& + modules() const; + inline ::google::protobuf::RepeatedPtrField< ::CodeModule >* + mutable_modules(); + + // optional string os = 7; + inline bool has_os() const; + inline void clear_os(); + static const int kOsFieldNumber = 7; + inline const ::std::string& os() const; + inline void set_os(const ::std::string& value); + inline void set_os(const char* value); + inline void set_os(const char* value, size_t size); + inline ::std::string* mutable_os(); + + // optional string os_short = 8; + inline bool has_os_short() const; + inline void clear_os_short(); + static const int kOsShortFieldNumber = 8; + inline const ::std::string& os_short() const; + inline void set_os_short(const ::std::string& value); + inline void set_os_short(const char* value); + inline void set_os_short(const char* value, size_t size); + inline ::std::string* mutable_os_short(); + + // optional string os_version = 9; + inline bool has_os_version() const; + inline void clear_os_version(); + static const int kOsVersionFieldNumber = 9; + inline const ::std::string& os_version() const; + inline void set_os_version(const ::std::string& value); + inline void set_os_version(const char* value); + inline void set_os_version(const char* value, size_t size); + inline ::std::string* mutable_os_version(); + + // optional string cpu = 10; + inline bool has_cpu() const; + inline void clear_cpu(); + static const int kCpuFieldNumber = 10; + inline const ::std::string& cpu() const; + inline void set_cpu(const ::std::string& value); + inline void set_cpu(const char* value); + inline void set_cpu(const char* value, size_t size); + inline ::std::string* mutable_cpu(); + + // optional string cpu_info = 11; + inline bool has_cpu_info() const; + inline void clear_cpu_info(); + static const int kCpuInfoFieldNumber = 11; + inline const ::std::string& cpu_info() const; + inline void set_cpu_info(const ::std::string& value); + inline void set_cpu_info(const char* value); + inline void set_cpu_info(const char* value, size_t size); + inline ::std::string* mutable_cpu_info(); + + // optional int32 cpu_count = 12; + inline bool has_cpu_count() const; + inline void clear_cpu_count(); + static const int kCpuCountFieldNumber = 12; + inline ::google::protobuf::int32 cpu_count() const; + inline void set_cpu_count(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:ProcessStateProto) + private: + ::google::protobuf::UnknownFieldSet _unknown_fields_; + mutable int _cached_size_; + + ::google::protobuf::int64 time_date_stamp_; + ::ProcessStateProto_Crash* crash_; + ::std::string* assertion_; + static const ::std::string _default_assertion_; + ::google::protobuf::int32 requesting_thread_; + ::google::protobuf::RepeatedPtrField< ::ProcessStateProto_Thread > threads_; + ::google::protobuf::RepeatedPtrField< ::CodeModule > modules_; + ::std::string* os_; + static const ::std::string _default_os_; + ::std::string* os_short_; + static const ::std::string _default_os_short_; + ::std::string* os_version_; + static const ::std::string _default_os_version_; + ::std::string* cpu_; + static const ::std::string _default_cpu_; + ::std::string* cpu_info_; + static const ::std::string _default_cpu_info_; + ::google::protobuf::int32 cpu_count_; + friend void protobuf_AddDesc_process_5fstate_2eproto(); + friend void protobuf_AssignDesc_process_5fstate_2eproto(); + friend void protobuf_ShutdownFile_process_5fstate_2eproto(); + + ::google::protobuf::uint32 _has_bits_[(12 + 31) / 32]; + + // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? + inline bool _has_bit(int index) const { + return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; + } + inline void _set_bit(int index) { + _has_bits_[index / 32] |= (1u << (index % 32)); + } + inline void _clear_bit(int index) { + _has_bits_[index / 32] &= ~(1u << (index % 32)); + } + + void InitAsDefaultInstance(); + static ProcessStateProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class StackFrame : public ::google::protobuf::Message { + public: + StackFrame(); + virtual ~StackFrame(); + + StackFrame(const StackFrame& from); + + inline StackFrame& operator=(const StackFrame& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const StackFrame& default_instance(); + + void Swap(StackFrame* other); + + // implements Message ---------------------------------------------- + + StackFrame* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const StackFrame& from); + void MergeFrom(const StackFrame& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required int64 instruction = 1; + inline bool has_instruction() const; + inline void clear_instruction(); + static const int kInstructionFieldNumber = 1; + inline ::google::protobuf::int64 instruction() const; + inline void set_instruction(::google::protobuf::int64 value); + + // optional .CodeModule module = 2; + inline bool has_module() const; + inline void clear_module(); + static const int kModuleFieldNumber = 2; + inline const ::CodeModule& module() const; + inline ::CodeModule* mutable_module(); + + // optional string function_name = 3; + inline bool has_function_name() const; + inline void clear_function_name(); + static const int kFunctionNameFieldNumber = 3; + inline const ::std::string& function_name() const; + inline void set_function_name(const ::std::string& value); + inline void set_function_name(const char* value); + inline void set_function_name(const char* value, size_t size); + inline ::std::string* mutable_function_name(); + + // optional int64 function_base = 4; + inline bool has_function_base() const; + inline void clear_function_base(); + static const int kFunctionBaseFieldNumber = 4; + inline ::google::protobuf::int64 function_base() const; + inline void set_function_base(::google::protobuf::int64 value); + + // optional string source_file_name = 5; + inline bool has_source_file_name() const; + inline void clear_source_file_name(); + static const int kSourceFileNameFieldNumber = 5; + inline const ::std::string& source_file_name() const; + inline void set_source_file_name(const ::std::string& value); + inline void set_source_file_name(const char* value); + inline void set_source_file_name(const char* value, size_t size); + inline ::std::string* mutable_source_file_name(); + + // optional int32 source_line = 6; + inline bool has_source_line() const; + inline void clear_source_line(); + static const int kSourceLineFieldNumber = 6; + inline ::google::protobuf::int32 source_line() const; + inline void set_source_line(::google::protobuf::int32 value); + + // optional int64 source_line_base = 7; + inline bool has_source_line_base() const; + inline void clear_source_line_base(); + static const int kSourceLineBaseFieldNumber = 7; + inline ::google::protobuf::int64 source_line_base() const; + inline void set_source_line_base(::google::protobuf::int64 value); + + // @@protoc_insertion_point(class_scope:StackFrame) + private: + ::google::protobuf::UnknownFieldSet _unknown_fields_; + mutable int _cached_size_; + + ::google::protobuf::int64 instruction_; + ::CodeModule* module_; + ::std::string* function_name_; + static const ::std::string _default_function_name_; + ::google::protobuf::int64 function_base_; + ::std::string* source_file_name_; + static const ::std::string _default_source_file_name_; + ::google::protobuf::int32 source_line_; + ::google::protobuf::int64 source_line_base_; + friend void protobuf_AddDesc_process_5fstate_2eproto(); + friend void protobuf_AssignDesc_process_5fstate_2eproto(); + friend void protobuf_ShutdownFile_process_5fstate_2eproto(); + + ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32]; + + // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? + inline bool _has_bit(int index) const { + return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; + } + inline void _set_bit(int index) { + _has_bits_[index / 32] |= (1u << (index % 32)); + } + inline void _clear_bit(int index) { + _has_bits_[index / 32] &= ~(1u << (index % 32)); + } + + void InitAsDefaultInstance(); + static StackFrame* default_instance_; +}; +// ------------------------------------------------------------------- + +class CodeModule : public ::google::protobuf::Message { + public: + CodeModule(); + virtual ~CodeModule(); + + CodeModule(const CodeModule& from); + + inline CodeModule& operator=(const CodeModule& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const CodeModule& default_instance(); + + void Swap(CodeModule* other); + + // implements Message ---------------------------------------------- + + CodeModule* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const CodeModule& from); + void MergeFrom(const CodeModule& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional int64 base_address = 1; + inline bool has_base_address() const; + inline void clear_base_address(); + static const int kBaseAddressFieldNumber = 1; + inline ::google::protobuf::int64 base_address() const; + inline void set_base_address(::google::protobuf::int64 value); + + // optional int64 size = 2; + inline bool has_size() const; + inline void clear_size(); + static const int kSizeFieldNumber = 2; + inline ::google::protobuf::int64 size() const; + inline void set_size(::google::protobuf::int64 value); + + // optional string code_file = 3; + inline bool has_code_file() const; + inline void clear_code_file(); + static const int kCodeFileFieldNumber = 3; + inline const ::std::string& code_file() const; + inline void set_code_file(const ::std::string& value); + inline void set_code_file(const char* value); + inline void set_code_file(const char* value, size_t size); + inline ::std::string* mutable_code_file(); + + // optional string code_identifier = 4; + inline bool has_code_identifier() const; + inline void clear_code_identifier(); + static const int kCodeIdentifierFieldNumber = 4; + inline const ::std::string& code_identifier() const; + inline void set_code_identifier(const ::std::string& value); + inline void set_code_identifier(const char* value); + inline void set_code_identifier(const char* value, size_t size); + inline ::std::string* mutable_code_identifier(); + + // optional string debug_file = 5; + inline bool has_debug_file() const; + inline void clear_debug_file(); + static const int kDebugFileFieldNumber = 5; + inline const ::std::string& debug_file() const; + inline void set_debug_file(const ::std::string& value); + inline void set_debug_file(const char* value); + inline void set_debug_file(const char* value, size_t size); + inline ::std::string* mutable_debug_file(); + + // optional string debug_identifier = 6; + inline bool has_debug_identifier() const; + inline void clear_debug_identifier(); + static const int kDebugIdentifierFieldNumber = 6; + inline const ::std::string& debug_identifier() const; + inline void set_debug_identifier(const ::std::string& value); + inline void set_debug_identifier(const char* value); + inline void set_debug_identifier(const char* value, size_t size); + inline ::std::string* mutable_debug_identifier(); + + // optional string version = 7; + inline bool has_version() const; + inline void clear_version(); + static const int kVersionFieldNumber = 7; + inline const ::std::string& version() const; + inline void set_version(const ::std::string& value); + inline void set_version(const char* value); + inline void set_version(const char* value, size_t size); + inline ::std::string* mutable_version(); + + // @@protoc_insertion_point(class_scope:CodeModule) + private: + ::google::protobuf::UnknownFieldSet _unknown_fields_; + mutable int _cached_size_; + + ::google::protobuf::int64 base_address_; + ::google::protobuf::int64 size_; + ::std::string* code_file_; + static const ::std::string _default_code_file_; + ::std::string* code_identifier_; + static const ::std::string _default_code_identifier_; + ::std::string* debug_file_; + static const ::std::string _default_debug_file_; + ::std::string* debug_identifier_; + static const ::std::string _default_debug_identifier_; + ::std::string* version_; + static const ::std::string _default_version_; + friend void protobuf_AddDesc_process_5fstate_2eproto(); + friend void protobuf_AssignDesc_process_5fstate_2eproto(); + friend void protobuf_ShutdownFile_process_5fstate_2eproto(); + + ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32]; + + // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? + inline bool _has_bit(int index) const { + return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; + } + inline void _set_bit(int index) { + _has_bits_[index / 32] |= (1u << (index % 32)); + } + inline void _clear_bit(int index) { + _has_bits_[index / 32] &= ~(1u << (index % 32)); + } + + void InitAsDefaultInstance(); + static CodeModule* default_instance_; +}; +// =================================================================== + + +// =================================================================== + +// ProcessStateProto_Crash + +// required string reason = 1; +inline bool ProcessStateProto_Crash::has_reason() const { + return _has_bit(0); +} +inline void ProcessStateProto_Crash::clear_reason() { + if (reason_ != &_default_reason_) { + reason_->clear(); + } + _clear_bit(0); +} +inline const ::std::string& ProcessStateProto_Crash::reason() const { + return *reason_; +} +inline void ProcessStateProto_Crash::set_reason(const ::std::string& value) { + _set_bit(0); + if (reason_ == &_default_reason_) { + reason_ = new ::std::string; + } + reason_->assign(value); +} +inline void ProcessStateProto_Crash::set_reason(const char* value) { + _set_bit(0); + if (reason_ == &_default_reason_) { + reason_ = new ::std::string; + } + reason_->assign(value); +} +inline void ProcessStateProto_Crash::set_reason(const char* value, size_t size) { + _set_bit(0); + if (reason_ == &_default_reason_) { + reason_ = new ::std::string; + } + reason_->assign(reinterpret_cast(value), size); +} +inline ::std::string* ProcessStateProto_Crash::mutable_reason() { + _set_bit(0); + if (reason_ == &_default_reason_) { + reason_ = new ::std::string; + } + return reason_; +} + +// required int64 address = 2; +inline bool ProcessStateProto_Crash::has_address() const { + return _has_bit(1); +} +inline void ProcessStateProto_Crash::clear_address() { + address_ = GOOGLE_LONGLONG(0); + _clear_bit(1); +} +inline ::google::protobuf::int64 ProcessStateProto_Crash::address() const { + return address_; +} +inline void ProcessStateProto_Crash::set_address(::google::protobuf::int64 value) { + _set_bit(1); + address_ = value; +} + +// ------------------------------------------------------------------- + +// ProcessStateProto_Thread + +// repeated .StackFrame frames = 1; +inline int ProcessStateProto_Thread::frames_size() const { + return frames_.size(); +} +inline void ProcessStateProto_Thread::clear_frames() { + frames_.Clear(); +} +inline const ::StackFrame& ProcessStateProto_Thread::frames(int index) const { + return frames_.Get(index); +} +inline ::StackFrame* ProcessStateProto_Thread::mutable_frames(int index) { + return frames_.Mutable(index); +} +inline ::StackFrame* ProcessStateProto_Thread::add_frames() { + return frames_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::StackFrame >& +ProcessStateProto_Thread::frames() const { + return frames_; +} +inline ::google::protobuf::RepeatedPtrField< ::StackFrame >* +ProcessStateProto_Thread::mutable_frames() { + return &frames_; +} + +// ------------------------------------------------------------------- + +// ProcessStateProto + +// optional int64 time_date_stamp = 1; +inline bool ProcessStateProto::has_time_date_stamp() const { + return _has_bit(0); +} +inline void ProcessStateProto::clear_time_date_stamp() { + time_date_stamp_ = GOOGLE_LONGLONG(0); + _clear_bit(0); +} +inline ::google::protobuf::int64 ProcessStateProto::time_date_stamp() const { + return time_date_stamp_; +} +inline void ProcessStateProto::set_time_date_stamp(::google::protobuf::int64 value) { + _set_bit(0); + time_date_stamp_ = value; +} + +// optional .ProcessStateProto.Crash crash = 2; +inline bool ProcessStateProto::has_crash() const { + return _has_bit(1); +} +inline void ProcessStateProto::clear_crash() { + if (crash_ != NULL) crash_->::ProcessStateProto_Crash::Clear(); + _clear_bit(1); +} +inline const ::ProcessStateProto_Crash& ProcessStateProto::crash() const { + return crash_ != NULL ? *crash_ : *default_instance_->crash_; +} +inline ::ProcessStateProto_Crash* ProcessStateProto::mutable_crash() { + _set_bit(1); + if (crash_ == NULL) crash_ = new ::ProcessStateProto_Crash; + return crash_; +} + +// optional string assertion = 3; +inline bool ProcessStateProto::has_assertion() const { + return _has_bit(2); +} +inline void ProcessStateProto::clear_assertion() { + if (assertion_ != &_default_assertion_) { + assertion_->clear(); + } + _clear_bit(2); +} +inline const ::std::string& ProcessStateProto::assertion() const { + return *assertion_; +} +inline void ProcessStateProto::set_assertion(const ::std::string& value) { + _set_bit(2); + if (assertion_ == &_default_assertion_) { + assertion_ = new ::std::string; + } + assertion_->assign(value); +} +inline void ProcessStateProto::set_assertion(const char* value) { + _set_bit(2); + if (assertion_ == &_default_assertion_) { + assertion_ = new ::std::string; + } + assertion_->assign(value); +} +inline void ProcessStateProto::set_assertion(const char* value, size_t size) { + _set_bit(2); + if (assertion_ == &_default_assertion_) { + assertion_ = new ::std::string; + } + assertion_->assign(reinterpret_cast(value), size); +} +inline ::std::string* ProcessStateProto::mutable_assertion() { + _set_bit(2); + if (assertion_ == &_default_assertion_) { + assertion_ = new ::std::string; + } + return assertion_; +} + +// optional int32 requesting_thread = 4; +inline bool ProcessStateProto::has_requesting_thread() const { + return _has_bit(3); +} +inline void ProcessStateProto::clear_requesting_thread() { + requesting_thread_ = 0; + _clear_bit(3); +} +inline ::google::protobuf::int32 ProcessStateProto::requesting_thread() const { + return requesting_thread_; +} +inline void ProcessStateProto::set_requesting_thread(::google::protobuf::int32 value) { + _set_bit(3); + requesting_thread_ = value; +} + +// repeated .ProcessStateProto.Thread threads = 5; +inline int ProcessStateProto::threads_size() const { + return threads_.size(); +} +inline void ProcessStateProto::clear_threads() { + threads_.Clear(); +} +inline const ::ProcessStateProto_Thread& ProcessStateProto::threads(int index) const { + return threads_.Get(index); +} +inline ::ProcessStateProto_Thread* ProcessStateProto::mutable_threads(int index) { + return threads_.Mutable(index); +} +inline ::ProcessStateProto_Thread* ProcessStateProto::add_threads() { + return threads_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::ProcessStateProto_Thread >& +ProcessStateProto::threads() const { + return threads_; +} +inline ::google::protobuf::RepeatedPtrField< ::ProcessStateProto_Thread >* +ProcessStateProto::mutable_threads() { + return &threads_; +} + +// repeated .CodeModule modules = 6; +inline int ProcessStateProto::modules_size() const { + return modules_.size(); +} +inline void ProcessStateProto::clear_modules() { + modules_.Clear(); +} +inline const ::CodeModule& ProcessStateProto::modules(int index) const { + return modules_.Get(index); +} +inline ::CodeModule* ProcessStateProto::mutable_modules(int index) { + return modules_.Mutable(index); +} +inline ::CodeModule* ProcessStateProto::add_modules() { + return modules_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::CodeModule >& +ProcessStateProto::modules() const { + return modules_; +} +inline ::google::protobuf::RepeatedPtrField< ::CodeModule >* +ProcessStateProto::mutable_modules() { + return &modules_; +} + +// optional string os = 7; +inline bool ProcessStateProto::has_os() const { + return _has_bit(6); +} +inline void ProcessStateProto::clear_os() { + if (os_ != &_default_os_) { + os_->clear(); + } + _clear_bit(6); +} +inline const ::std::string& ProcessStateProto::os() const { + return *os_; +} +inline void ProcessStateProto::set_os(const ::std::string& value) { + _set_bit(6); + if (os_ == &_default_os_) { + os_ = new ::std::string; + } + os_->assign(value); +} +inline void ProcessStateProto::set_os(const char* value) { + _set_bit(6); + if (os_ == &_default_os_) { + os_ = new ::std::string; + } + os_->assign(value); +} +inline void ProcessStateProto::set_os(const char* value, size_t size) { + _set_bit(6); + if (os_ == &_default_os_) { + os_ = new ::std::string; + } + os_->assign(reinterpret_cast(value), size); +} +inline ::std::string* ProcessStateProto::mutable_os() { + _set_bit(6); + if (os_ == &_default_os_) { + os_ = new ::std::string; + } + return os_; +} + +// optional string os_short = 8; +inline bool ProcessStateProto::has_os_short() const { + return _has_bit(7); +} +inline void ProcessStateProto::clear_os_short() { + if (os_short_ != &_default_os_short_) { + os_short_->clear(); + } + _clear_bit(7); +} +inline const ::std::string& ProcessStateProto::os_short() const { + return *os_short_; +} +inline void ProcessStateProto::set_os_short(const ::std::string& value) { + _set_bit(7); + if (os_short_ == &_default_os_short_) { + os_short_ = new ::std::string; + } + os_short_->assign(value); +} +inline void ProcessStateProto::set_os_short(const char* value) { + _set_bit(7); + if (os_short_ == &_default_os_short_) { + os_short_ = new ::std::string; + } + os_short_->assign(value); +} +inline void ProcessStateProto::set_os_short(const char* value, size_t size) { + _set_bit(7); + if (os_short_ == &_default_os_short_) { + os_short_ = new ::std::string; + } + os_short_->assign(reinterpret_cast(value), size); +} +inline ::std::string* ProcessStateProto::mutable_os_short() { + _set_bit(7); + if (os_short_ == &_default_os_short_) { + os_short_ = new ::std::string; + } + return os_short_; +} + +// optional string os_version = 9; +inline bool ProcessStateProto::has_os_version() const { + return _has_bit(8); +} +inline void ProcessStateProto::clear_os_version() { + if (os_version_ != &_default_os_version_) { + os_version_->clear(); + } + _clear_bit(8); +} +inline const ::std::string& ProcessStateProto::os_version() const { + return *os_version_; +} +inline void ProcessStateProto::set_os_version(const ::std::string& value) { + _set_bit(8); + if (os_version_ == &_default_os_version_) { + os_version_ = new ::std::string; + } + os_version_->assign(value); +} +inline void ProcessStateProto::set_os_version(const char* value) { + _set_bit(8); + if (os_version_ == &_default_os_version_) { + os_version_ = new ::std::string; + } + os_version_->assign(value); +} +inline void ProcessStateProto::set_os_version(const char* value, size_t size) { + _set_bit(8); + if (os_version_ == &_default_os_version_) { + os_version_ = new ::std::string; + } + os_version_->assign(reinterpret_cast(value), size); +} +inline ::std::string* ProcessStateProto::mutable_os_version() { + _set_bit(8); + if (os_version_ == &_default_os_version_) { + os_version_ = new ::std::string; + } + return os_version_; +} + +// optional string cpu = 10; +inline bool ProcessStateProto::has_cpu() const { + return _has_bit(9); +} +inline void ProcessStateProto::clear_cpu() { + if (cpu_ != &_default_cpu_) { + cpu_->clear(); + } + _clear_bit(9); +} +inline const ::std::string& ProcessStateProto::cpu() const { + return *cpu_; +} +inline void ProcessStateProto::set_cpu(const ::std::string& value) { + _set_bit(9); + if (cpu_ == &_default_cpu_) { + cpu_ = new ::std::string; + } + cpu_->assign(value); +} +inline void ProcessStateProto::set_cpu(const char* value) { + _set_bit(9); + if (cpu_ == &_default_cpu_) { + cpu_ = new ::std::string; + } + cpu_->assign(value); +} +inline void ProcessStateProto::set_cpu(const char* value, size_t size) { + _set_bit(9); + if (cpu_ == &_default_cpu_) { + cpu_ = new ::std::string; + } + cpu_->assign(reinterpret_cast(value), size); +} +inline ::std::string* ProcessStateProto::mutable_cpu() { + _set_bit(9); + if (cpu_ == &_default_cpu_) { + cpu_ = new ::std::string; + } + return cpu_; +} + +// optional string cpu_info = 11; +inline bool ProcessStateProto::has_cpu_info() const { + return _has_bit(10); +} +inline void ProcessStateProto::clear_cpu_info() { + if (cpu_info_ != &_default_cpu_info_) { + cpu_info_->clear(); + } + _clear_bit(10); +} +inline const ::std::string& ProcessStateProto::cpu_info() const { + return *cpu_info_; +} +inline void ProcessStateProto::set_cpu_info(const ::std::string& value) { + _set_bit(10); + if (cpu_info_ == &_default_cpu_info_) { + cpu_info_ = new ::std::string; + } + cpu_info_->assign(value); +} +inline void ProcessStateProto::set_cpu_info(const char* value) { + _set_bit(10); + if (cpu_info_ == &_default_cpu_info_) { + cpu_info_ = new ::std::string; + } + cpu_info_->assign(value); +} +inline void ProcessStateProto::set_cpu_info(const char* value, size_t size) { + _set_bit(10); + if (cpu_info_ == &_default_cpu_info_) { + cpu_info_ = new ::std::string; + } + cpu_info_->assign(reinterpret_cast(value), size); +} +inline ::std::string* ProcessStateProto::mutable_cpu_info() { + _set_bit(10); + if (cpu_info_ == &_default_cpu_info_) { + cpu_info_ = new ::std::string; + } + return cpu_info_; +} + +// optional int32 cpu_count = 12; +inline bool ProcessStateProto::has_cpu_count() const { + return _has_bit(11); +} +inline void ProcessStateProto::clear_cpu_count() { + cpu_count_ = 0; + _clear_bit(11); +} +inline ::google::protobuf::int32 ProcessStateProto::cpu_count() const { + return cpu_count_; +} +inline void ProcessStateProto::set_cpu_count(::google::protobuf::int32 value) { + _set_bit(11); + cpu_count_ = value; +} + +// ------------------------------------------------------------------- + +// StackFrame + +// required int64 instruction = 1; +inline bool StackFrame::has_instruction() const { + return _has_bit(0); +} +inline void StackFrame::clear_instruction() { + instruction_ = GOOGLE_LONGLONG(0); + _clear_bit(0); +} +inline ::google::protobuf::int64 StackFrame::instruction() const { + return instruction_; +} +inline void StackFrame::set_instruction(::google::protobuf::int64 value) { + _set_bit(0); + instruction_ = value; +} + +// optional .CodeModule module = 2; +inline bool StackFrame::has_module() const { + return _has_bit(1); +} +inline void StackFrame::clear_module() { + if (module_ != NULL) module_->::CodeModule::Clear(); + _clear_bit(1); +} +inline const ::CodeModule& StackFrame::module() const { + return module_ != NULL ? *module_ : *default_instance_->module_; +} +inline ::CodeModule* StackFrame::mutable_module() { + _set_bit(1); + if (module_ == NULL) module_ = new ::CodeModule; + return module_; +} + +// optional string function_name = 3; +inline bool StackFrame::has_function_name() const { + return _has_bit(2); +} +inline void StackFrame::clear_function_name() { + if (function_name_ != &_default_function_name_) { + function_name_->clear(); + } + _clear_bit(2); +} +inline const ::std::string& StackFrame::function_name() const { + return *function_name_; +} +inline void StackFrame::set_function_name(const ::std::string& value) { + _set_bit(2); + if (function_name_ == &_default_function_name_) { + function_name_ = new ::std::string; + } + function_name_->assign(value); +} +inline void StackFrame::set_function_name(const char* value) { + _set_bit(2); + if (function_name_ == &_default_function_name_) { + function_name_ = new ::std::string; + } + function_name_->assign(value); +} +inline void StackFrame::set_function_name(const char* value, size_t size) { + _set_bit(2); + if (function_name_ == &_default_function_name_) { + function_name_ = new ::std::string; + } + function_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* StackFrame::mutable_function_name() { + _set_bit(2); + if (function_name_ == &_default_function_name_) { + function_name_ = new ::std::string; + } + return function_name_; +} + +// optional int64 function_base = 4; +inline bool StackFrame::has_function_base() const { + return _has_bit(3); +} +inline void StackFrame::clear_function_base() { + function_base_ = GOOGLE_LONGLONG(0); + _clear_bit(3); +} +inline ::google::protobuf::int64 StackFrame::function_base() const { + return function_base_; +} +inline void StackFrame::set_function_base(::google::protobuf::int64 value) { + _set_bit(3); + function_base_ = value; +} + +// optional string source_file_name = 5; +inline bool StackFrame::has_source_file_name() const { + return _has_bit(4); +} +inline void StackFrame::clear_source_file_name() { + if (source_file_name_ != &_default_source_file_name_) { + source_file_name_->clear(); + } + _clear_bit(4); +} +inline const ::std::string& StackFrame::source_file_name() const { + return *source_file_name_; +} +inline void StackFrame::set_source_file_name(const ::std::string& value) { + _set_bit(4); + if (source_file_name_ == &_default_source_file_name_) { + source_file_name_ = new ::std::string; + } + source_file_name_->assign(value); +} +inline void StackFrame::set_source_file_name(const char* value) { + _set_bit(4); + if (source_file_name_ == &_default_source_file_name_) { + source_file_name_ = new ::std::string; + } + source_file_name_->assign(value); +} +inline void StackFrame::set_source_file_name(const char* value, size_t size) { + _set_bit(4); + if (source_file_name_ == &_default_source_file_name_) { + source_file_name_ = new ::std::string; + } + source_file_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* StackFrame::mutable_source_file_name() { + _set_bit(4); + if (source_file_name_ == &_default_source_file_name_) { + source_file_name_ = new ::std::string; + } + return source_file_name_; +} + +// optional int32 source_line = 6; +inline bool StackFrame::has_source_line() const { + return _has_bit(5); +} +inline void StackFrame::clear_source_line() { + source_line_ = 0; + _clear_bit(5); +} +inline ::google::protobuf::int32 StackFrame::source_line() const { + return source_line_; +} +inline void StackFrame::set_source_line(::google::protobuf::int32 value) { + _set_bit(5); + source_line_ = value; +} + +// optional int64 source_line_base = 7; +inline bool StackFrame::has_source_line_base() const { + return _has_bit(6); +} +inline void StackFrame::clear_source_line_base() { + source_line_base_ = GOOGLE_LONGLONG(0); + _clear_bit(6); +} +inline ::google::protobuf::int64 StackFrame::source_line_base() const { + return source_line_base_; +} +inline void StackFrame::set_source_line_base(::google::protobuf::int64 value) { + _set_bit(6); + source_line_base_ = value; +} + +// ------------------------------------------------------------------- + +// CodeModule + +// optional int64 base_address = 1; +inline bool CodeModule::has_base_address() const { + return _has_bit(0); +} +inline void CodeModule::clear_base_address() { + base_address_ = GOOGLE_LONGLONG(0); + _clear_bit(0); +} +inline ::google::protobuf::int64 CodeModule::base_address() const { + return base_address_; +} +inline void CodeModule::set_base_address(::google::protobuf::int64 value) { + _set_bit(0); + base_address_ = value; +} + +// optional int64 size = 2; +inline bool CodeModule::has_size() const { + return _has_bit(1); +} +inline void CodeModule::clear_size() { + size_ = GOOGLE_LONGLONG(0); + _clear_bit(1); +} +inline ::google::protobuf::int64 CodeModule::size() const { + return size_; +} +inline void CodeModule::set_size(::google::protobuf::int64 value) { + _set_bit(1); + size_ = value; +} + +// optional string code_file = 3; +inline bool CodeModule::has_code_file() const { + return _has_bit(2); +} +inline void CodeModule::clear_code_file() { + if (code_file_ != &_default_code_file_) { + code_file_->clear(); + } + _clear_bit(2); +} +inline const ::std::string& CodeModule::code_file() const { + return *code_file_; +} +inline void CodeModule::set_code_file(const ::std::string& value) { + _set_bit(2); + if (code_file_ == &_default_code_file_) { + code_file_ = new ::std::string; + } + code_file_->assign(value); +} +inline void CodeModule::set_code_file(const char* value) { + _set_bit(2); + if (code_file_ == &_default_code_file_) { + code_file_ = new ::std::string; + } + code_file_->assign(value); +} +inline void CodeModule::set_code_file(const char* value, size_t size) { + _set_bit(2); + if (code_file_ == &_default_code_file_) { + code_file_ = new ::std::string; + } + code_file_->assign(reinterpret_cast(value), size); +} +inline ::std::string* CodeModule::mutable_code_file() { + _set_bit(2); + if (code_file_ == &_default_code_file_) { + code_file_ = new ::std::string; + } + return code_file_; +} + +// optional string code_identifier = 4; +inline bool CodeModule::has_code_identifier() const { + return _has_bit(3); +} +inline void CodeModule::clear_code_identifier() { + if (code_identifier_ != &_default_code_identifier_) { + code_identifier_->clear(); + } + _clear_bit(3); +} +inline const ::std::string& CodeModule::code_identifier() const { + return *code_identifier_; +} +inline void CodeModule::set_code_identifier(const ::std::string& value) { + _set_bit(3); + if (code_identifier_ == &_default_code_identifier_) { + code_identifier_ = new ::std::string; + } + code_identifier_->assign(value); +} +inline void CodeModule::set_code_identifier(const char* value) { + _set_bit(3); + if (code_identifier_ == &_default_code_identifier_) { + code_identifier_ = new ::std::string; + } + code_identifier_->assign(value); +} +inline void CodeModule::set_code_identifier(const char* value, size_t size) { + _set_bit(3); + if (code_identifier_ == &_default_code_identifier_) { + code_identifier_ = new ::std::string; + } + code_identifier_->assign(reinterpret_cast(value), size); +} +inline ::std::string* CodeModule::mutable_code_identifier() { + _set_bit(3); + if (code_identifier_ == &_default_code_identifier_) { + code_identifier_ = new ::std::string; + } + return code_identifier_; +} + +// optional string debug_file = 5; +inline bool CodeModule::has_debug_file() const { + return _has_bit(4); +} +inline void CodeModule::clear_debug_file() { + if (debug_file_ != &_default_debug_file_) { + debug_file_->clear(); + } + _clear_bit(4); +} +inline const ::std::string& CodeModule::debug_file() const { + return *debug_file_; +} +inline void CodeModule::set_debug_file(const ::std::string& value) { + _set_bit(4); + if (debug_file_ == &_default_debug_file_) { + debug_file_ = new ::std::string; + } + debug_file_->assign(value); +} +inline void CodeModule::set_debug_file(const char* value) { + _set_bit(4); + if (debug_file_ == &_default_debug_file_) { + debug_file_ = new ::std::string; + } + debug_file_->assign(value); +} +inline void CodeModule::set_debug_file(const char* value, size_t size) { + _set_bit(4); + if (debug_file_ == &_default_debug_file_) { + debug_file_ = new ::std::string; + } + debug_file_->assign(reinterpret_cast(value), size); +} +inline ::std::string* CodeModule::mutable_debug_file() { + _set_bit(4); + if (debug_file_ == &_default_debug_file_) { + debug_file_ = new ::std::string; + } + return debug_file_; +} + +// optional string debug_identifier = 6; +inline bool CodeModule::has_debug_identifier() const { + return _has_bit(5); +} +inline void CodeModule::clear_debug_identifier() { + if (debug_identifier_ != &_default_debug_identifier_) { + debug_identifier_->clear(); + } + _clear_bit(5); +} +inline const ::std::string& CodeModule::debug_identifier() const { + return *debug_identifier_; +} +inline void CodeModule::set_debug_identifier(const ::std::string& value) { + _set_bit(5); + if (debug_identifier_ == &_default_debug_identifier_) { + debug_identifier_ = new ::std::string; + } + debug_identifier_->assign(value); +} +inline void CodeModule::set_debug_identifier(const char* value) { + _set_bit(5); + if (debug_identifier_ == &_default_debug_identifier_) { + debug_identifier_ = new ::std::string; + } + debug_identifier_->assign(value); +} +inline void CodeModule::set_debug_identifier(const char* value, size_t size) { + _set_bit(5); + if (debug_identifier_ == &_default_debug_identifier_) { + debug_identifier_ = new ::std::string; + } + debug_identifier_->assign(reinterpret_cast(value), size); +} +inline ::std::string* CodeModule::mutable_debug_identifier() { + _set_bit(5); + if (debug_identifier_ == &_default_debug_identifier_) { + debug_identifier_ = new ::std::string; + } + return debug_identifier_; +} + +// optional string version = 7; +inline bool CodeModule::has_version() const { + return _has_bit(6); +} +inline void CodeModule::clear_version() { + if (version_ != &_default_version_) { + version_->clear(); + } + _clear_bit(6); +} +inline const ::std::string& CodeModule::version() const { + return *version_; +} +inline void CodeModule::set_version(const ::std::string& value) { + _set_bit(6); + if (version_ == &_default_version_) { + version_ = new ::std::string; + } + version_->assign(value); +} +inline void CodeModule::set_version(const char* value) { + _set_bit(6); + if (version_ == &_default_version_) { + version_ = new ::std::string; + } + version_->assign(value); +} +inline void CodeModule::set_version(const char* value, size_t size) { + _set_bit(6); + if (version_ == &_default_version_) { + version_ = new ::std::string; + } + version_->assign(reinterpret_cast(value), size); +} +inline ::std::string* CodeModule::mutable_version() { + _set_bit(6); + if (version_ == &_default_version_) { + version_ = new ::std::string; + } + return version_; +} + + +// @@protoc_insertion_point(namespace_scope) + +#ifndef SWIG +namespace google { +namespace protobuf { + + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_process_5fstate_2eproto__INCLUDED diff --git a/src/processor/proto/process_state.proto b/src/processor/proto/process_state.proto new file mode 100644 index 00000000..209919c2 --- /dev/null +++ b/src/processor/proto/process_state.proto @@ -0,0 +1,204 @@ +// Copyright (c) 2010, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// process_state_proto.proto: A client proto representation of a process, +// in a fully-digested state. +// +// Derived from earlier struct and class based models of a client-side +// processed minidump found under src/google_breakpad/processor. The +// file process_state.h holds the top level representation of this model, +// supported by additional classes. We've added a proto representation +// to ease serialization and parsing for server-side storage of crash +// reports processed on the client. +// +// Author: Jess Gray + + +// A proto representation of a process, in a fully-digested state. +// See src/google_breakpad/processor/process_state.h +message ProcessStateProto { + // Next value: 13 + + // The time-date stamp of the original minidump (time_t format) + optional int64 time_date_stamp = 1; + + message Crash { + // The type of crash. OS- and possibly CPU- specific. For example, + // "EXCEPTION_ACCESS_VIOLATION" (Windows), "EXC_BAD_ACCESS / + // KERN_INVALID_ADDRESS" (Mac OS X), "SIGSEGV" (other Unix). + required string reason = 1; + + // If crash_reason implicates memory, the memory address that caused the + // crash. For data access errors, this will be the data address that + // caused the fault. For code errors, this will be the address of the + // instruction that caused the fault. + required int64 address = 2; + } + optional Crash crash = 2; + + + // If there was an assertion that was hit, a textual representation + // of that assertion, possibly including the file and line at which + // it occurred. + optional string assertion = 3; + + // The index of the thread that requested a dump be written in the + // threads vector. If a dump was produced as a result of a crash, this + // will point to the thread that crashed. If the dump was produced as + // by user code without crashing, and the dump contains extended Breakpad + // information, this will point to the thread that requested the dump. + optional int32 requesting_thread = 4; + + message Thread { + // Stack for the given thread + repeated StackFrame frames = 1; + } + + // Stacks for each thread (except possibly the exception handler + // thread) at the time of the crash. + repeated Thread threads = 5; + + // The modules that were loaded into the process represented by the + // ProcessState. + repeated CodeModule modules = 6; + + // System Info: OS and CPU + + // A string identifying the operating system, such as "Windows NT", + // "Mac OS X", or "Linux". If the information is present in the dump but + // its value is unknown, this field will contain a numeric value. If + // the information is not present in the dump, this field will be empty. + optional string os = 7; + + // A short form of the os string, using lowercase letters and no spaces, + // suitable for use in a filesystem. Possible values are "windows", + // "mac", and "linux". Empty if the information is not present in the dump + // or if the OS given by the dump is unknown. The values stored in this + // field should match those used by MinidumpSystemInfo::GetOS. + optional string os_short = 8; + + // A string identifying the version of the operating system, such as + // "5.1.2600 Service Pack 2" or "10.4.8 8L2127". If the dump does not + // contain this information, this field will be empty. + optional string os_version = 9; + + // A string identifying the basic CPU family, such as "x86" or "ppc". + // If this information is present in the dump but its value is unknown, + // this field will contain a numeric value. If the information is not + // present in the dump, this field will be empty. The values stored in + // this field should match those used by MinidumpSystemInfo::GetCPU. + optional string cpu = 10; + + // A string further identifying the specific CPU, such as + // "GenuineIntel level 6 model 13 stepping 8". If the information is not + // present in the dump, or additional identifying information is not + // defined for the CPU family, this field will be empty. + optional string cpu_info = 11; + + // The number of processors in the system. Will be greater than one for + // multi-core systems. + optional int32 cpu_count = 12; + + // Leave the ability to add the raw minidump to this representation +} + + +// Represents a single frame in a stack +// See src/google_breakpad/processor/code_module.h +message StackFrame { + // Next value: 8 + + // The program counter location as an absolute virtual address. For the + // innermost called frame in a stack, this will be an exact program counter + // or instruction pointer value. For all other frames, this will be within + // the instruction that caused execution to branch to a called function, + // but may not necessarily point to the exact beginning of that instruction. + required int64 instruction = 1; + + // The module in which the instruction resides. + optional CodeModule module = 2; + + // The function name, may be omitted if debug symbols are not available. + optional string function_name = 3; + + // The start address of the function, may be omitted if debug symbols + // are not available. + optional int64 function_base = 4; + + // The source file name, may be omitted if debug symbols are not available. + optional string source_file_name = 5; + + // The (1-based) source line number, may be omitted if debug symbols are + // not available. + optional int32 source_line = 6; + + // The start address of the source line, may be omitted if debug symbols + // are not available. + optional int64 source_line_base = 7; +} + + +// Carries information about code modules that are loaded into a process. +// See src/google_breakpad/processor/code_module.h +message CodeModule { + // Next value: 8 + + // The base address of this code module as it was loaded by the process. + optional int64 base_address = 1; + + // The size of the code module. + optional int64 size = 2; + + // The path or file name that the code module was loaded from. + optional string code_file = 3; + + // An identifying string used to discriminate between multiple versions and + // builds of the same code module. This may contain a uuid, timestamp, + // version number, or any combination of this or other information, in an + // implementation-defined format. + optional string code_identifier = 4; + + // The filename containing debugging information associated with the code + // module. If debugging information is stored in a file separate from the + // code module itself (as is the case when .pdb or .dSYM files are used), + // this will be different from code_file. If debugging information is + // stored in the code module itself (possibly prior to stripping), this + // will be the same as code_file. + optional string debug_file = 5; + + // An identifying string similar to code_identifier, but identifies a + // specific version and build of the associated debug file. This may be + // the same as code_identifier when the debug_file and code_file are + // identical or when the same identifier is used to identify distinct + // debug and code files. + optional string debug_identifier = 6; + + // A human-readable representation of the code module's version. + optional string version = 7; +} -- cgit v1.2.1