aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorjessicag.feedback@gmail.com <jessicag.feedback@gmail.com@4c0a9323-5329-0410-9bdc-e9ce6186880e>2010-08-24 17:32:45 +0000
committerjessicag.feedback@gmail.com <jessicag.feedback@gmail.com@4c0a9323-5329-0410-9bdc-e9ce6186880e>2010-08-24 17:32:45 +0000
commitf8bca185b92f9a8547ad0979b09d4c3119719b59 (patch)
tree55beba24523df72b537d6e74ebfeab5493225630 /src
parentPatch from CDN to add support for an exploitability engine (diff)
downloadbreakpad-f8bca185b92f9a8547ad0979b09d4c3119719b59.tar.xz
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
Diffstat (limited to 'src')
-rw-r--r--src/processor/proto/README23
-rw-r--r--src/processor/proto/process_state.pb.cc2498
-rw-r--r--src/processor/proto/process_state.pb.h1644
-rw-r--r--src/processor/proto/process_state.proto204
4 files changed, 4369 insertions, 0 deletions
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 <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+
+namespace {
+
+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<const ProcessStateProto_Crash*>(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void ProcessStateProto_Crash::MergeFrom(const ProcessStateProto_Crash& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_reason(from.reason());
+ }
+ if (from._has_bit(1)) {
+ set_address(from.address());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ProcessStateProto_Crash::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void ProcessStateProto_Crash::CopyFrom(const ProcessStateProto_Crash& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool ProcessStateProto_Crash::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+ return true;
+}
+
+void ProcessStateProto_Crash::Swap(ProcessStateProto_Crash* other) {
+ if (other != this) {
+ std::swap(reason_, other->reason_);
+ std::swap(address_, other->address_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata ProcessStateProto_Crash::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = ProcessStateProto_Crash_descriptor_;
+ metadata.reflection = ProcessStateProto_Crash_reflection_;
+ return metadata;
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ProcessStateProto_Thread::kFramesFieldNumber;
+#endif // !_MSC_VER
+
+ProcessStateProto_Thread::ProcessStateProto_Thread()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void ProcessStateProto_Thread::InitAsDefaultInstance() {
+}
+
+ProcessStateProto_Thread::ProcessStateProto_Thread(const ProcessStateProto_Thread& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void ProcessStateProto_Thread::SharedCtor() {
+ _cached_size_ = 0;
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ProcessStateProto_Thread::~ProcessStateProto_Thread() {
+ SharedDtor();
+}
+
+void ProcessStateProto_Thread::SharedDtor() {
+ if (this != default_instance_) {
+ }
+}
+
+void ProcessStateProto_Thread::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ProcessStateProto_Thread::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return ProcessStateProto_Thread_descriptor_;
+}
+
+const ProcessStateProto_Thread& ProcessStateProto_Thread::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_process_5fstate_2eproto(); return *default_instance_;
+}
+
+ProcessStateProto_Thread* ProcessStateProto_Thread::default_instance_ = NULL;
+
+ProcessStateProto_Thread* ProcessStateProto_Thread::New() const {
+ return new ProcessStateProto_Thread;
+}
+
+void ProcessStateProto_Thread::Clear() {
+ frames_.Clear();
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool ProcessStateProto_Thread::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // repeated .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<const ProcessStateProto_Thread*>(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void ProcessStateProto_Thread::MergeFrom(const ProcessStateProto_Thread& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ frames_.MergeFrom(from.frames_);
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ProcessStateProto_Thread::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void ProcessStateProto_Thread::CopyFrom(const ProcessStateProto_Thread& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool ProcessStateProto_Thread::IsInitialized() const {
+
+ for (int i = 0; i < frames_size(); i++) {
+ if (!this->frames(i).IsInitialized()) return false;
+ }
+ return true;
+}
+
+void ProcessStateProto_Thread::Swap(ProcessStateProto_Thread* other) {
+ if (other != this) {
+ frames_.Swap(&other->frames_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata ProcessStateProto_Thread::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = ProcessStateProto_Thread_descriptor_;
+ metadata.reflection = ProcessStateProto_Thread_reflection_;
+ return metadata;
+}
+
+
+// -------------------------------------------------------------------
+
+const ::std::string ProcessStateProto::_default_assertion_;
+const ::std::string ProcessStateProto::_default_os_;
+const ::std::string ProcessStateProto::_default_os_short_;
+const ::std::string ProcessStateProto::_default_os_version_;
+const ::std::string ProcessStateProto::_default_cpu_;
+const ::std::string ProcessStateProto::_default_cpu_info_;
+#ifndef _MSC_VER
+const int ProcessStateProto::kTimeDateStampFieldNumber;
+const int ProcessStateProto::kCrashFieldNumber;
+const int ProcessStateProto::kAssertionFieldNumber;
+const int ProcessStateProto::kRequestingThreadFieldNumber;
+const int ProcessStateProto::kThreadsFieldNumber;
+const int ProcessStateProto::kModulesFieldNumber;
+const int ProcessStateProto::kOsFieldNumber;
+const int ProcessStateProto::kOsShortFieldNumber;
+const int ProcessStateProto::kOsVersionFieldNumber;
+const int ProcessStateProto::kCpuFieldNumber;
+const int ProcessStateProto::kCpuInfoFieldNumber;
+const int ProcessStateProto::kCpuCountFieldNumber;
+#endif // !_MSC_VER
+
+ProcessStateProto::ProcessStateProto()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void ProcessStateProto::InitAsDefaultInstance() {
+ crash_ = const_cast< ::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<const ProcessStateProto*>(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void ProcessStateProto::MergeFrom(const ProcessStateProto& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ threads_.MergeFrom(from.threads_);
+ modules_.MergeFrom(from.modules_);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_time_date_stamp(from.time_date_stamp());
+ }
+ if (from._has_bit(1)) {
+ mutable_crash()->::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<const StackFrame*>(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void StackFrame::MergeFrom(const StackFrame& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_instruction(from.instruction());
+ }
+ if (from._has_bit(1)) {
+ mutable_module()->::CodeModule::MergeFrom(from.module());
+ }
+ if (from._has_bit(2)) {
+ set_function_name(from.function_name());
+ }
+ if (from._has_bit(3)) {
+ set_function_base(from.function_base());
+ }
+ if (from._has_bit(4)) {
+ set_source_file_name(from.source_file_name());
+ }
+ if (from._has_bit(5)) {
+ set_source_line(from.source_line());
+ }
+ if (from._has_bit(6)) {
+ set_source_line_base(from.source_line_base());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StackFrame::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void StackFrame::CopyFrom(const StackFrame& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool StackFrame::IsInitialized() const {
+ if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+ return true;
+}
+
+void StackFrame::Swap(StackFrame* other) {
+ if (other != this) {
+ std::swap(instruction_, other->instruction_);
+ std::swap(module_, other->module_);
+ std::swap(function_name_, other->function_name_);
+ std::swap(function_base_, other->function_base_);
+ std::swap(source_file_name_, other->source_file_name_);
+ std::swap(source_line_, other->source_line_);
+ std::swap(source_line_base_, other->source_line_base_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata StackFrame::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = StackFrame_descriptor_;
+ metadata.reflection = StackFrame_reflection_;
+ return metadata;
+}
+
+
+// ===================================================================
+
+const ::std::string CodeModule::_default_code_file_;
+const ::std::string CodeModule::_default_code_identifier_;
+const ::std::string CodeModule::_default_debug_file_;
+const ::std::string CodeModule::_default_debug_identifier_;
+const ::std::string CodeModule::_default_version_;
+#ifndef _MSC_VER
+const int CodeModule::kBaseAddressFieldNumber;
+const int CodeModule::kSizeFieldNumber;
+const int CodeModule::kCodeFileFieldNumber;
+const int CodeModule::kCodeIdentifierFieldNumber;
+const int CodeModule::kDebugFileFieldNumber;
+const int CodeModule::kDebugIdentifierFieldNumber;
+const int CodeModule::kVersionFieldNumber;
+#endif // !_MSC_VER
+
+CodeModule::CodeModule()
+ : ::google::protobuf::Message() {
+ SharedCtor();
+}
+
+void CodeModule::InitAsDefaultInstance() {
+}
+
+CodeModule::CodeModule(const CodeModule& from)
+ : ::google::protobuf::Message() {
+ SharedCtor();
+ MergeFrom(from);
+}
+
+void CodeModule::SharedCtor() {
+ _cached_size_ = 0;
+ base_address_ = GOOGLE_LONGLONG(0);
+ size_ = GOOGLE_LONGLONG(0);
+ code_file_ = const_cast< ::std::string*>(&_default_code_file_);
+ code_identifier_ = const_cast< ::std::string*>(&_default_code_identifier_);
+ debug_file_ = const_cast< ::std::string*>(&_default_debug_file_);
+ debug_identifier_ = const_cast< ::std::string*>(&_default_debug_identifier_);
+ version_ = const_cast< ::std::string*>(&_default_version_);
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CodeModule::~CodeModule() {
+ SharedDtor();
+}
+
+void CodeModule::SharedDtor() {
+ if (code_file_ != &_default_code_file_) {
+ delete code_file_;
+ }
+ if (code_identifier_ != &_default_code_identifier_) {
+ delete code_identifier_;
+ }
+ if (debug_file_ != &_default_debug_file_) {
+ delete debug_file_;
+ }
+ if (debug_identifier_ != &_default_debug_identifier_) {
+ delete debug_identifier_;
+ }
+ if (version_ != &_default_version_) {
+ delete version_;
+ }
+ if (this != default_instance_) {
+ }
+}
+
+void CodeModule::SetCachedSize(int size) const {
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CodeModule::descriptor() {
+ protobuf_AssignDescriptorsOnce();
+ return CodeModule_descriptor_;
+}
+
+const CodeModule& CodeModule::default_instance() {
+ if (default_instance_ == NULL) protobuf_AddDesc_process_5fstate_2eproto(); return *default_instance_;
+}
+
+CodeModule* CodeModule::default_instance_ = NULL;
+
+CodeModule* CodeModule::New() const {
+ return new CodeModule;
+}
+
+void CodeModule::Clear() {
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ base_address_ = GOOGLE_LONGLONG(0);
+ size_ = GOOGLE_LONGLONG(0);
+ if (_has_bit(2)) {
+ if (code_file_ != &_default_code_file_) {
+ code_file_->clear();
+ }
+ }
+ if (_has_bit(3)) {
+ if (code_identifier_ != &_default_code_identifier_) {
+ code_identifier_->clear();
+ }
+ }
+ if (_has_bit(4)) {
+ if (debug_file_ != &_default_debug_file_) {
+ debug_file_->clear();
+ }
+ }
+ if (_has_bit(5)) {
+ if (debug_identifier_ != &_default_debug_identifier_) {
+ debug_identifier_->clear();
+ }
+ }
+ if (_has_bit(6)) {
+ if (version_ != &_default_version_) {
+ version_->clear();
+ }
+ }
+ }
+ ::memset(_has_bits_, 0, sizeof(_has_bits_));
+ mutable_unknown_fields()->Clear();
+}
+
+bool CodeModule::MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+ ::google::protobuf::uint32 tag;
+ while ((tag = input->ReadTag()) != 0) {
+ switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+ // optional int64 base_address = 1;
+ case 1: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+ input, &base_address_)));
+ _set_bit(0);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(16)) goto parse_size;
+ break;
+ }
+
+ // optional int64 size = 2;
+ case 2: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+ parse_size:
+ DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+ ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+ input, &size_)));
+ _set_bit(1);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(26)) goto parse_code_file;
+ break;
+ }
+
+ // optional string code_file = 3;
+ case 3: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_code_file:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_code_file()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->code_file().data(), this->code_file().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(34)) goto parse_code_identifier;
+ break;
+ }
+
+ // optional string code_identifier = 4;
+ case 4: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_code_identifier:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_code_identifier()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->code_identifier().data(), this->code_identifier().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(42)) goto parse_debug_file;
+ break;
+ }
+
+ // optional string debug_file = 5;
+ case 5: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_debug_file:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_debug_file()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->debug_file().data(), this->debug_file().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(50)) goto parse_debug_identifier;
+ break;
+ }
+
+ // optional string debug_identifier = 6;
+ case 6: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_debug_identifier:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_debug_identifier()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->debug_identifier().data(), this->debug_identifier().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectTag(58)) goto parse_version;
+ break;
+ }
+
+ // optional string version = 7;
+ case 7: {
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ parse_version:
+ DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+ input, this->mutable_version()));
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->version().data(), this->version().length(),
+ ::google::protobuf::internal::WireFormat::PARSE);
+ } else {
+ goto handle_uninterpreted;
+ }
+ if (input->ExpectAtEnd()) return true;
+ break;
+ }
+
+ default: {
+ handle_uninterpreted:
+ if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+ ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+ return true;
+ }
+ DO_(::google::protobuf::internal::WireFormat::SkipField(
+ input, tag, mutable_unknown_fields()));
+ break;
+ }
+ }
+ }
+ return true;
+#undef DO_
+}
+
+void CodeModule::SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const {
+ // optional int64 base_address = 1;
+ if (_has_bit(0)) {
+ ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->base_address(), output);
+ }
+
+ // optional int64 size = 2;
+ if (_has_bit(1)) {
+ ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->size(), output);
+ }
+
+ // optional string code_file = 3;
+ if (_has_bit(2)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->code_file().data(), this->code_file().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ ::google::protobuf::internal::WireFormatLite::WriteString(
+ 3, this->code_file(), output);
+ }
+
+ // optional string code_identifier = 4;
+ if (_has_bit(3)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->code_identifier().data(), this->code_identifier().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ ::google::protobuf::internal::WireFormatLite::WriteString(
+ 4, this->code_identifier(), output);
+ }
+
+ // optional string debug_file = 5;
+ if (_has_bit(4)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->debug_file().data(), this->debug_file().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ ::google::protobuf::internal::WireFormatLite::WriteString(
+ 5, this->debug_file(), output);
+ }
+
+ // optional string debug_identifier = 6;
+ if (_has_bit(5)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->debug_identifier().data(), this->debug_identifier().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ ::google::protobuf::internal::WireFormatLite::WriteString(
+ 6, this->debug_identifier(), output);
+ }
+
+ // optional string version = 7;
+ if (_has_bit(6)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->version().data(), this->version().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ ::google::protobuf::internal::WireFormatLite::WriteString(
+ 7, this->version(), output);
+ }
+
+ if (!unknown_fields().empty()) {
+ ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+ unknown_fields(), output);
+ }
+}
+
+::google::protobuf::uint8* CodeModule::SerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const {
+ // optional int64 base_address = 1;
+ if (_has_bit(0)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->base_address(), target);
+ }
+
+ // optional int64 size = 2;
+ if (_has_bit(1)) {
+ target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->size(), target);
+ }
+
+ // optional string code_file = 3;
+ if (_has_bit(2)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->code_file().data(), this->code_file().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 3, this->code_file(), target);
+ }
+
+ // optional string code_identifier = 4;
+ if (_has_bit(3)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->code_identifier().data(), this->code_identifier().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 4, this->code_identifier(), target);
+ }
+
+ // optional string debug_file = 5;
+ if (_has_bit(4)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->debug_file().data(), this->debug_file().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 5, this->debug_file(), target);
+ }
+
+ // optional string debug_identifier = 6;
+ if (_has_bit(5)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->debug_identifier().data(), this->debug_identifier().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 6, this->debug_identifier(), target);
+ }
+
+ // optional string version = 7;
+ if (_has_bit(6)) {
+ ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+ this->version().data(), this->version().length(),
+ ::google::protobuf::internal::WireFormat::SERIALIZE);
+ target =
+ ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+ 7, this->version(), target);
+ }
+
+ if (!unknown_fields().empty()) {
+ target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+ unknown_fields(), target);
+ }
+ return target;
+}
+
+int CodeModule::ByteSize() const {
+ int total_size = 0;
+
+ if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ // optional int64 base_address = 1;
+ if (has_base_address()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::Int64Size(
+ this->base_address());
+ }
+
+ // optional int64 size = 2;
+ if (has_size()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::Int64Size(
+ this->size());
+ }
+
+ // optional string code_file = 3;
+ if (has_code_file()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->code_file());
+ }
+
+ // optional string code_identifier = 4;
+ if (has_code_identifier()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->code_identifier());
+ }
+
+ // optional string debug_file = 5;
+ if (has_debug_file()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->debug_file());
+ }
+
+ // optional string debug_identifier = 6;
+ if (has_debug_identifier()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->debug_identifier());
+ }
+
+ // optional string version = 7;
+ if (has_version()) {
+ total_size += 1 +
+ ::google::protobuf::internal::WireFormatLite::StringSize(
+ this->version());
+ }
+
+ }
+ if (!unknown_fields().empty()) {
+ total_size +=
+ ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+ unknown_fields());
+ }
+ GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+ _cached_size_ = total_size;
+ GOOGLE_SAFE_CONCURRENT_WRITES_END();
+ return total_size;
+}
+
+void CodeModule::MergeFrom(const ::google::protobuf::Message& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ const CodeModule* source =
+ ::google::protobuf::internal::dynamic_cast_if_available<const CodeModule*>(
+ &from);
+ if (source == NULL) {
+ ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+ } else {
+ MergeFrom(*source);
+ }
+}
+
+void CodeModule::MergeFrom(const CodeModule& from) {
+ GOOGLE_CHECK_NE(&from, this);
+ if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+ if (from._has_bit(0)) {
+ set_base_address(from.base_address());
+ }
+ if (from._has_bit(1)) {
+ set_size(from.size());
+ }
+ if (from._has_bit(2)) {
+ set_code_file(from.code_file());
+ }
+ if (from._has_bit(3)) {
+ set_code_identifier(from.code_identifier());
+ }
+ if (from._has_bit(4)) {
+ set_debug_file(from.debug_file());
+ }
+ if (from._has_bit(5)) {
+ set_debug_identifier(from.debug_identifier());
+ }
+ if (from._has_bit(6)) {
+ set_version(from.version());
+ }
+ }
+ mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CodeModule::CopyFrom(const ::google::protobuf::Message& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void CodeModule::CopyFrom(const CodeModule& from) {
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool CodeModule::IsInitialized() const {
+
+ return true;
+}
+
+void CodeModule::Swap(CodeModule* other) {
+ if (other != this) {
+ std::swap(base_address_, other->base_address_);
+ std::swap(size_, other->size_);
+ std::swap(code_file_, other->code_file_);
+ std::swap(code_identifier_, other->code_identifier_);
+ std::swap(debug_file_, other->debug_file_);
+ std::swap(debug_identifier_, other->debug_identifier_);
+ std::swap(version_, other->version_);
+ std::swap(_has_bits_[0], other->_has_bits_[0]);
+ _unknown_fields_.Swap(&other->_unknown_fields_);
+ std::swap(_cached_size_, other->_cached_size_);
+ }
+}
+
+::google::protobuf::Metadata CodeModule::GetMetadata() const {
+ protobuf_AssignDescriptorsOnce();
+ ::google::protobuf::Metadata metadata;
+ metadata.descriptor = CodeModule_descriptor_;
+ metadata.reflection = CodeModule_reflection_;
+ return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+// @@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 <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#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 <google/protobuf/generated_message_util.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/generated_message_reflection.h>
+// @@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<const char*>(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<const char*>(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<const char*>(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<const char*>(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<const char*>(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<const char*>(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<const char*>(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<const char*>(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<const char*>(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<const char*>(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<const char*>(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<const char*>(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<const char*>(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<const char*>(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;
+}