src/third_party/protobuf/src/google/protobuf/compiler/plugin.pb.cc

   1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
   2 // source: google/protobuf/compiler/plugin.proto
   3
   4 #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
   5 #include "google/protobuf/compiler/plugin.pb.h"
   6
   7 #include <algorithm>
   8
   9 #include <google/protobuf/stubs/common.h>
  10 #include <google/protobuf/stubs/once.h>
  11 #include <google/protobuf/io/coded_stream.h>
  12 #include <google/protobuf/wire_format_lite_inl.h>
  13 #include <google/protobuf/descriptor.h>
  14 #include <google/protobuf/generated_message_reflection.h>
  15 #include <google/protobuf/reflection_ops.h>
  16 #include <google/protobuf/wire_format.h>
  17 // @@protoc_insertion_point(includes)
  18
  19 namespace google {
  20 namespace protobuf {
  21 namespace compiler {
  22
  23 namespace {
  24
  25 const ::google::protobuf::Descriptor* CodeGeneratorRequest_descriptor_ = NULL;
  26 const ::google::protobuf::internal::GeneratedMessageReflection*
  27   CodeGeneratorRequest_reflection_ = NULL;
  28 const ::google::protobuf::Descriptor* CodeGeneratorResponse_descriptor_ = NULL;
  29 const ::google::protobuf::internal::GeneratedMessageReflection*
  30   CodeGeneratorResponse_reflection_ = NULL;
  31 const ::google::protobuf::Descriptor* CodeGeneratorResponse_File_descriptor_ = NULL;
  32 const ::google::protobuf::internal::GeneratedMessageReflection*
  33   CodeGeneratorResponse_File_reflection_ = NULL;
  34
  35 }  // namespace
  36
  37
  38 void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto() {
  39   protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
  40   const ::google::protobuf::FileDescriptor* file =
  41     ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
  42       "google/protobuf/compiler/plugin.proto");
  43   GOOGLE_CHECK(file != NULL);
  44   CodeGeneratorRequest_descriptor_ = file->message_type(0);
  45   static const int CodeGeneratorRequest_offsets_[3] = {
  46     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, file_to_generate_),
  47     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, parameter_),
  48     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, proto_file_),
  49   };
  50   CodeGeneratorRequest_reflection_ =
  51     new ::google::protobuf::internal::GeneratedMessageReflection(
  52       CodeGeneratorRequest_descriptor_,
  53       CodeGeneratorRequest::default_instance_,
  54       CodeGeneratorRequest_offsets_,
  55       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, _has_bits_[0]),
  56       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, _unknown_fields_),
  57       -1,
  58       ::google::protobuf::DescriptorPool::generated_pool(),
  59       ::google::protobuf::MessageFactory::generated_factory(),
  60       sizeof(CodeGeneratorRequest));
  61   CodeGeneratorResponse_descriptor_ = file->message_type(1);
  62   static const int CodeGeneratorResponse_offsets_[2] = {
  63     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse, error_),
  64     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse, file_),
  65   };
  66   CodeGeneratorResponse_reflection_ =
  67     new ::google::protobuf::internal::GeneratedMessageReflection(
  68       CodeGeneratorResponse_descriptor_,
  69       CodeGeneratorResponse::default_instance_,
  70       CodeGeneratorResponse_offsets_,
  71       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse, _has_bits_[0]),
  72       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse, _unknown_fields_),
  73       -1,
  74       ::google::protobuf::DescriptorPool::generated_pool(),
  75       ::google::protobuf::MessageFactory::generated_factory(),
  76       sizeof(CodeGeneratorResponse));
  77   CodeGeneratorResponse_File_descriptor_ = CodeGeneratorResponse_descriptor_->nested_type(0);
  78   static const int CodeGeneratorResponse_File_offsets_[3] = {
  79     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, name_),
  80     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, insertion_point_),
  81     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, content_),
  82   };
  83   CodeGeneratorResponse_File_reflection_ =
  84     new ::google::protobuf::internal::GeneratedMessageReflection(
  85       CodeGeneratorResponse_File_descriptor_,
  86       CodeGeneratorResponse_File::default_instance_,
  87       CodeGeneratorResponse_File_offsets_,
  88       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, _has_bits_[0]),
  89       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, _unknown_fields_),
  90       -1,
  91       ::google::protobuf::DescriptorPool::generated_pool(),
  92       ::google::protobuf::MessageFactory::generated_factory(),
  93       sizeof(CodeGeneratorResponse_File));
  94 }
  95
  96 namespace {
  97
  98 GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
  99 inline void protobuf_AssignDescriptorsOnce() {
 100   ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
 101                  &protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto);
 102 }
 103
 104 void protobuf_RegisterTypes(const ::std::string&) {
 105   protobuf_AssignDescriptorsOnce();
 106   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 107     CodeGeneratorRequest_descriptor_, &CodeGeneratorRequest::default_instance());
 108   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 109     CodeGeneratorResponse_descriptor_, &CodeGeneratorResponse::default_instance());
 110   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 111     CodeGeneratorResponse_File_descriptor_, &CodeGeneratorResponse_File::default_instance());
 112 }
 113
 114 }  // namespace
 115
 116 void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto() {
 117   delete CodeGeneratorRequest::default_instance_;
 118   delete CodeGeneratorRequest_reflection_;
 119   delete CodeGeneratorResponse::default_instance_;
 120   delete CodeGeneratorResponse_reflection_;
 121   delete CodeGeneratorResponse_File::default_instance_;
 122   delete CodeGeneratorResponse_File_reflection_;
 123 }
 124
 125 void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto() {
 126   static bool already_here = false;
 127   if (already_here) return;
 128   already_here = true;
 129   GOOGLE_PROTOBUF_VERIFY_VERSION;
 130
 131   ::google::protobuf::protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 132   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
 133     "\n%google/protobuf/compiler/plugin.proto\022"
 134     "\030google.protobuf.compiler\032 google/protob"
 135     "uf/descriptor.proto\"}\n\024CodeGeneratorRequ"
 136     "est\022\030\n\020file_to_generate\030\001 \003(\t\022\021\n\tparamet"
 137     "er\030\002 \001(\t\0228\n\nproto_file\030\017 \003(\0132$.google.pr"
 138     "otobuf.FileDescriptorProto\"\252\001\n\025CodeGener"
 139     "atorResponse\022\r\n\005error\030\001 \001(\t\022B\n\004file\030\017 \003("
 140     "\01324.google.protobuf.compiler.CodeGenerat"
 141     "orResponse.File\032>\n\004File\022\014\n\004name\030\001 \001(\t\022\027\n"
 142     "\017insertion_point\030\002 \001(\t\022\017\n\007content\030\017 \001(\tB"
 143     ",\n\034com.google.protobuf.compilerB\014PluginP"
 144     "rotos", 445);
 145   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
 146     "google/protobuf/compiler/plugin.proto", &protobuf_RegisterTypes);
 147   CodeGeneratorRequest::default_instance_ = new CodeGeneratorRequest();
 148   CodeGeneratorResponse::default_instance_ = new CodeGeneratorResponse();
 149   CodeGeneratorResponse_File::default_instance_ = new CodeGeneratorResponse_File();
 150   CodeGeneratorRequest::default_instance_->InitAsDefaultInstance();
 151   CodeGeneratorResponse::default_instance_->InitAsDefaultInstance();
 152   CodeGeneratorResponse_File::default_instance_->InitAsDefaultInstance();
 153   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto);
 154 }
 155
 156 // Force AddDescriptors() to be called at static initialization time.
 157 struct StaticDescriptorInitializer_google_2fprotobuf_2fcompiler_2fplugin_2eproto {
 158   StaticDescriptorInitializer_google_2fprotobuf_2fcompiler_2fplugin_2eproto() {
 159     protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
 160   }
 161 } static_descriptor_initializer_google_2fprotobuf_2fcompiler_2fplugin_2eproto_;
 162
 163 // ===================================================================
 164
 165 #ifndef _MSC_VER
 166 const int CodeGeneratorRequest::kFileToGenerateFieldNumber;
 167 const int CodeGeneratorRequest::kParameterFieldNumber;
 168 const int CodeGeneratorRequest::kProtoFileFieldNumber;
 169 #endif  // !_MSC_VER
 170
 171 CodeGeneratorRequest::CodeGeneratorRequest()
 172   : ::google::protobuf::Message() {
 173   SharedCtor();
 174 }
 175
 176 void CodeGeneratorRequest::InitAsDefaultInstance() {
 177 }
 178
 179 CodeGeneratorRequest::CodeGeneratorRequest(const CodeGeneratorRequest& from)
 180   : ::google::protobuf::Message() {
 181   SharedCtor();
 182   MergeFrom(from);
 183 }
 184
 185 void CodeGeneratorRequest::SharedCtor() {
 186   _cached_size_ = 0;
 187   parameter_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 188   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 189 }
 190
 191 CodeGeneratorRequest::~CodeGeneratorRequest() {
 192   SharedDtor();
 193 }
 194
 195 void CodeGeneratorRequest::SharedDtor() {
 196   if (parameter_ != &::google::protobuf::internal::kEmptyString) {
 197     delete parameter_;
 198   }
 199   if (this != default_instance_) {
 200   }
 201 }
 202
 203 void CodeGeneratorRequest::SetCachedSize(int size) const {
 204   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
 205   _cached_size_ = size;
 206   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 207 }
 208 const ::google::protobuf::Descriptor* CodeGeneratorRequest::descriptor() {
 209   protobuf_AssignDescriptorsOnce();
 210   return CodeGeneratorRequest_descriptor_;
 211 }
 212
 213 const CodeGeneratorRequest& CodeGeneratorRequest::default_instance() {
 214   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
 215   return *default_instance_;
 216 }
 217
 218 CodeGeneratorRequest* CodeGeneratorRequest::default_instance_ = NULL;
 219
 220 CodeGeneratorRequest* CodeGeneratorRequest::New() const {
 221   return new CodeGeneratorRequest;
 222 }
 223
 224 void CodeGeneratorRequest::Clear() {
 225   if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
 226     if (has_parameter()) {
 227       if (parameter_ != &::google::protobuf::internal::kEmptyString) {
 228         parameter_->clear();
 229       }
 230     }
 231   }
 232   file_to_generate_.Clear();
 233   proto_file_.Clear();
 234   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 235   mutable_unknown_fields()->Clear();
 236 }
 237
 238 bool CodeGeneratorRequest::MergePartialFromCodedStream(
 239     ::google::protobuf::io::CodedInputStream* input) {
 240 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
 241   ::google::protobuf::uint32 tag;
 242   while ((tag = input->ReadTag()) != 0) {
 243     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
 244       // repeated string file_to_generate = 1;
 245       case 1: {
 246         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 247             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 248          parse_file_to_generate:
 249           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
 250                 input, this->add_file_to_generate()));
 251           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 252             this->file_to_generate(this->file_to_generate_size() - 1).data(),
 253             this->file_to_generate(this->file_to_generate_size() - 1).length(),
 254             ::google::protobuf::internal::WireFormat::PARSE);
 255         } else {
 256           goto handle_uninterpreted;
 257         }
 258         if (input->ExpectTag(10)) goto parse_file_to_generate;
 259         if (input->ExpectTag(18)) goto parse_parameter;
 260         break;
 261       }
 262
 263       // optional string parameter = 2;
 264       case 2: {
 265         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 266             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 267          parse_parameter:
 268           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
 269                 input, this->mutable_parameter()));
 270           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 271             this->parameter().data(), this->parameter().length(),
 272             ::google::protobuf::internal::WireFormat::PARSE);
 273         } else {
 274           goto handle_uninterpreted;
 275         }
 276         if (input->ExpectTag(122)) goto parse_proto_file;
 277         break;
 278       }
 279
 280       // repeated .google.protobuf.FileDescriptorProto proto_file = 15;
 281       case 15: {
 282         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 283             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 284          parse_proto_file:
 285           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
 286                 input, add_proto_file()));
 287         } else {
 288           goto handle_uninterpreted;
 289         }
 290         if (input->ExpectTag(122)) goto parse_proto_file;
 291         if (input->ExpectAtEnd()) return true;
 292         break;
 293       }
 294
 295       default: {
 296       handle_uninterpreted:
 297         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 298             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
 299           return true;
 300         }
 301         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
 302               input, tag, mutable_unknown_fields()));
 303         break;
 304       }
 305     }
 306   }
 307   return true;
 308 #undef DO_
 309 }
 310
 311 void CodeGeneratorRequest::SerializeWithCachedSizes(
 312     ::google::protobuf::io::CodedOutputStream* output) const {
 313   // repeated string file_to_generate = 1;
 314   for (int i = 0; i < this->file_to_generate_size(); i++) {
 315   ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 316     this->file_to_generate(i).data(), this->file_to_generate(i).length(),
 317     ::google::protobuf::internal::WireFormat::SERIALIZE);
 318     ::google::protobuf::internal::WireFormatLite::WriteString(
 319       1, this->file_to_generate(i), output);
 320   }
 321
 322   // optional string parameter = 2;
 323   if (has_parameter()) {
 324     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 325       this->parameter().data(), this->parameter().length(),
 326       ::google::protobuf::internal::WireFormat::SERIALIZE);
 327     ::google::protobuf::internal::WireFormatLite::WriteString(
 328       2, this->parameter(), output);
 329   }
 330
 331   // repeated .google.protobuf.FileDescriptorProto proto_file = 15;
 332   for (int i = 0; i < this->proto_file_size(); i++) {
 333     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
 334       15, this->proto_file(i), output);
 335   }
 336
 337   if (!unknown_fields().empty()) {
 338     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
 339         unknown_fields(), output);
 340   }
 341 }
 342
 343 ::google::protobuf::uint8* CodeGeneratorRequest::SerializeWithCachedSizesToArray(
 344     ::google::protobuf::uint8* target) const {
 345   // repeated string file_to_generate = 1;
 346   for (int i = 0; i < this->file_to_generate_size(); i++) {
 347     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 348       this->file_to_generate(i).data(), this->file_to_generate(i).length(),
 349       ::google::protobuf::internal::WireFormat::SERIALIZE);
 350     target = ::google::protobuf::internal::WireFormatLite::
 351       WriteStringToArray(1, this->file_to_generate(i), target);
 352   }
 353
 354   // optional string parameter = 2;
 355   if (has_parameter()) {
 356     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 357       this->parameter().data(), this->parameter().length(),
 358       ::google::protobuf::internal::WireFormat::SERIALIZE);
 359     target =
 360       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
 361         2, this->parameter(), target);
 362   }
 363
 364   // repeated .google.protobuf.FileDescriptorProto proto_file = 15;
 365   for (int i = 0; i < this->proto_file_size(); i++) {
 366     target = ::google::protobuf::internal::WireFormatLite::
 367       WriteMessageNoVirtualToArray(
 368         15, this->proto_file(i), target);
 369   }
 370
 371   if (!unknown_fields().empty()) {
 372     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
 373         unknown_fields(), target);
 374   }
 375   return target;
 376 }
 377
 378 int CodeGeneratorRequest::ByteSize() const {
 379   int total_size = 0;
 380
 381   if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
 382     // optional string parameter = 2;
 383     if (has_parameter()) {
 384       total_size += 1 +
 385         ::google::protobuf::internal::WireFormatLite::StringSize(
 386           this->parameter());
 387     }
 388
 389   }
 390   // repeated string file_to_generate = 1;
 391   total_size += 1 * this->file_to_generate_size();
 392   for (int i = 0; i < this->file_to_generate_size(); i++) {
 393     total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
 394       this->file_to_generate(i));
 395   }
 396
 397   // repeated .google.protobuf.FileDescriptorProto proto_file = 15;
 398   total_size += 1 * this->proto_file_size();
 399   for (int i = 0; i < this->proto_file_size(); i++) {
 400     total_size +=
 401       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
 402         this->proto_file(i));
 403   }
 404
 405   if (!unknown_fields().empty()) {
 406     total_size +=
 407       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
 408         unknown_fields());
 409   }
 410   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
 411   _cached_size_ = total_size;
 412   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 413   return total_size;
 414 }
 415
 416 void CodeGeneratorRequest::MergeFrom(const ::google::protobuf::Message& from) {
 417   GOOGLE_CHECK_NE(&from, this);
 418   const CodeGeneratorRequest* source =
 419     ::google::protobuf::internal::dynamic_cast_if_available<const CodeGeneratorRequest*>(
 420       &from);
 421   if (source == NULL) {
 422     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
 423   } else {
 424     MergeFrom(*source);
 425   }
 426 }
 427
 428 void CodeGeneratorRequest::MergeFrom(const CodeGeneratorRequest& from) {
 429   GOOGLE_CHECK_NE(&from, this);
 430   file_to_generate_.MergeFrom(from.file_to_generate_);
 431   proto_file_.MergeFrom(from.proto_file_);
 432   if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
 433     if (from.has_parameter()) {
 434       set_parameter(from.parameter());
 435     }
 436   }
 437   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 438 }
 439
 440 void CodeGeneratorRequest::CopyFrom(const ::google::protobuf::Message& from) {
 441   if (&from == this) return;
 442   Clear();
 443   MergeFrom(from);
 444 }
 445
 446 void CodeGeneratorRequest::CopyFrom(const CodeGeneratorRequest& from) {
 447   if (&from == this) return;
 448   Clear();
 449   MergeFrom(from);
 450 }
 451
 452 bool CodeGeneratorRequest::IsInitialized() const {
 453
 454   for (int i = 0; i < proto_file_size(); i++) {
 455     if (!this->proto_file(i).IsInitialized()) return false;
 456   }
 457   return true;
 458 }
 459
 460 void CodeGeneratorRequest::Swap(CodeGeneratorRequest* other) {
 461   if (other != this) {
 462     file_to_generate_.Swap(&other->file_to_generate_);
 463     std::swap(parameter_, other->parameter_);
 464     proto_file_.Swap(&other->proto_file_);
 465     std::swap(_has_bits_[0], other->_has_bits_[0]);
 466     _unknown_fields_.Swap(&other->_unknown_fields_);
 467     std::swap(_cached_size_, other->_cached_size_);
 468   }
 469 }
 470
 471 ::google::protobuf::Metadata CodeGeneratorRequest::GetMetadata() const {
 472   protobuf_AssignDescriptorsOnce();
 473   ::google::protobuf::Metadata metadata;
 474   metadata.descriptor = CodeGeneratorRequest_descriptor_;
 475   metadata.reflection = CodeGeneratorRequest_reflection_;
 476   return metadata;
 477 }
 478
 479
 480 // ===================================================================
 481
 482 #ifndef _MSC_VER
 483 const int CodeGeneratorResponse_File::kNameFieldNumber;
 484 const int CodeGeneratorResponse_File::kInsertionPointFieldNumber;
 485 const int CodeGeneratorResponse_File::kContentFieldNumber;
 486 #endif  // !_MSC_VER
 487
 488 CodeGeneratorResponse_File::CodeGeneratorResponse_File()
 489   : ::google::protobuf::Message() {
 490   SharedCtor();
 491 }
 492
 493 void CodeGeneratorResponse_File::InitAsDefaultInstance() {
 494 }
 495
 496 CodeGeneratorResponse_File::CodeGeneratorResponse_File(const CodeGeneratorResponse_File& from)
 497   : ::google::protobuf::Message() {
 498   SharedCtor();
 499   MergeFrom(from);
 500 }
 501
 502 void CodeGeneratorResponse_File::SharedCtor() {
 503   _cached_size_ = 0;
 504   name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 505   insertion_point_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 506   content_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 507   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 508 }
 509
 510 CodeGeneratorResponse_File::~CodeGeneratorResponse_File() {
 511   SharedDtor();
 512 }
 513
 514 void CodeGeneratorResponse_File::SharedDtor() {
 515   if (name_ != &::google::protobuf::internal::kEmptyString) {
 516     delete name_;
 517   }
 518   if (insertion_point_ != &::google::protobuf::internal::kEmptyString) {
 519     delete insertion_point_;
 520   }
 521   if (content_ != &::google::protobuf::internal::kEmptyString) {
 522     delete content_;
 523   }
 524   if (this != default_instance_) {
 525   }
 526 }
 527
 528 void CodeGeneratorResponse_File::SetCachedSize(int size) const {
 529   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
 530   _cached_size_ = size;
 531   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 532 }
 533 const ::google::protobuf::Descriptor* CodeGeneratorResponse_File::descriptor() {
 534   protobuf_AssignDescriptorsOnce();
 535   return CodeGeneratorResponse_File_descriptor_;
 536 }
 537
 538 const CodeGeneratorResponse_File& CodeGeneratorResponse_File::default_instance() {
 539   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
 540   return *default_instance_;
 541 }
 542
 543 CodeGeneratorResponse_File* CodeGeneratorResponse_File::default_instance_ = NULL;
 544
 545 CodeGeneratorResponse_File* CodeGeneratorResponse_File::New() const {
 546   return new CodeGeneratorResponse_File;
 547 }
 548
 549 void CodeGeneratorResponse_File::Clear() {
 550   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
 551     if (has_name()) {
 552       if (name_ != &::google::protobuf::internal::kEmptyString) {
 553         name_->clear();
 554       }
 555     }
 556     if (has_insertion_point()) {
 557       if (insertion_point_ != &::google::protobuf::internal::kEmptyString) {
 558         insertion_point_->clear();
 559       }
 560     }
 561     if (has_content()) {
 562       if (content_ != &::google::protobuf::internal::kEmptyString) {
 563         content_->clear();
 564       }
 565     }
 566   }
 567   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 568   mutable_unknown_fields()->Clear();
 569 }
 570
 571 bool CodeGeneratorResponse_File::MergePartialFromCodedStream(
 572     ::google::protobuf::io::CodedInputStream* input) {
 573 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
 574   ::google::protobuf::uint32 tag;
 575   while ((tag = input->ReadTag()) != 0) {
 576     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
 577       // optional string name = 1;
 578       case 1: {
 579         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 580             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 581           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
 582                 input, this->mutable_name()));
 583           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 584             this->name().data(), this->name().length(),
 585             ::google::protobuf::internal::WireFormat::PARSE);
 586         } else {
 587           goto handle_uninterpreted;
 588         }
 589         if (input->ExpectTag(18)) goto parse_insertion_point;
 590         break;
 591       }
 592
 593       // optional string insertion_point = 2;
 594       case 2: {
 595         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 596             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 597          parse_insertion_point:
 598           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
 599                 input, this->mutable_insertion_point()));
 600           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 601             this->insertion_point().data(), this->insertion_point().length(),
 602             ::google::protobuf::internal::WireFormat::PARSE);
 603         } else {
 604           goto handle_uninterpreted;
 605         }
 606         if (input->ExpectTag(122)) goto parse_content;
 607         break;
 608       }
 609
 610       // optional string content = 15;
 611       case 15: {
 612         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 613             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 614          parse_content:
 615           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
 616                 input, this->mutable_content()));
 617           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 618             this->content().data(), this->content().length(),
 619             ::google::protobuf::internal::WireFormat::PARSE);
 620         } else {
 621           goto handle_uninterpreted;
 622         }
 623         if (input->ExpectAtEnd()) return true;
 624         break;
 625       }
 626
 627       default: {
 628       handle_uninterpreted:
 629         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 630             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
 631           return true;
 632         }
 633         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
 634               input, tag, mutable_unknown_fields()));
 635         break;
 636       }
 637     }
 638   }
 639   return true;
 640 #undef DO_
 641 }
 642
 643 void CodeGeneratorResponse_File::SerializeWithCachedSizes(
 644     ::google::protobuf::io::CodedOutputStream* output) const {
 645   // optional string name = 1;
 646   if (has_name()) {
 647     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 648       this->name().data(), this->name().length(),
 649       ::google::protobuf::internal::WireFormat::SERIALIZE);
 650     ::google::protobuf::internal::WireFormatLite::WriteString(
 651       1, this->name(), output);
 652   }
 653
 654   // optional string insertion_point = 2;
 655   if (has_insertion_point()) {
 656     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 657       this->insertion_point().data(), this->insertion_point().length(),
 658       ::google::protobuf::internal::WireFormat::SERIALIZE);
 659     ::google::protobuf::internal::WireFormatLite::WriteString(
 660       2, this->insertion_point(), output);
 661   }
 662
 663   // optional string content = 15;
 664   if (has_content()) {
 665     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 666       this->content().data(), this->content().length(),
 667       ::google::protobuf::internal::WireFormat::SERIALIZE);
 668     ::google::protobuf::internal::WireFormatLite::WriteString(
 669       15, this->content(), output);
 670   }
 671
 672   if (!unknown_fields().empty()) {
 673     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
 674         unknown_fields(), output);
 675   }
 676 }
 677
 678 ::google::protobuf::uint8* CodeGeneratorResponse_File::SerializeWithCachedSizesToArray(
 679     ::google::protobuf::uint8* target) const {
 680   // optional string name = 1;
 681   if (has_name()) {
 682     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 683       this->name().data(), this->name().length(),
 684       ::google::protobuf::internal::WireFormat::SERIALIZE);
 685     target =
 686       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
 687         1, this->name(), target);
 688   }
 689
 690   // optional string insertion_point = 2;
 691   if (has_insertion_point()) {
 692     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 693       this->insertion_point().data(), this->insertion_point().length(),
 694       ::google::protobuf::internal::WireFormat::SERIALIZE);
 695     target =
 696       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
 697         2, this->insertion_point(), target);
 698   }
 699
 700   // optional string content = 15;
 701   if (has_content()) {
 702     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 703       this->content().data(), this->content().length(),
 704       ::google::protobuf::internal::WireFormat::SERIALIZE);
 705     target =
 706       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
 707         15, this->content(), target);
 708   }
 709
 710   if (!unknown_fields().empty()) {
 711     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
 712         unknown_fields(), target);
 713   }
 714   return target;
 715 }
 716
 717 int CodeGeneratorResponse_File::ByteSize() const {
 718   int total_size = 0;
 719
 720   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
 721     // optional string name = 1;
 722     if (has_name()) {
 723       total_size += 1 +
 724         ::google::protobuf::internal::WireFormatLite::StringSize(
 725           this->name());
 726     }
 727
 728     // optional string insertion_point = 2;
 729     if (has_insertion_point()) {
 730       total_size += 1 +
 731         ::google::protobuf::internal::WireFormatLite::StringSize(
 732           this->insertion_point());
 733     }
 734
 735     // optional string content = 15;
 736     if (has_content()) {
 737       total_size += 1 +
 738         ::google::protobuf::internal::WireFormatLite::StringSize(
 739           this->content());
 740     }
 741
 742   }
 743   if (!unknown_fields().empty()) {
 744     total_size +=
 745       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
 746         unknown_fields());
 747   }
 748   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
 749   _cached_size_ = total_size;
 750   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 751   return total_size;
 752 }
 753
 754 void CodeGeneratorResponse_File::MergeFrom(const ::google::protobuf::Message& from) {
 755   GOOGLE_CHECK_NE(&from, this);
 756   const CodeGeneratorResponse_File* source =
 757     ::google::protobuf::internal::dynamic_cast_if_available<const CodeGeneratorResponse_File*>(
 758       &from);
 759   if (source == NULL) {
 760     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
 761   } else {
 762     MergeFrom(*source);
 763   }
 764 }
 765
 766 void CodeGeneratorResponse_File::MergeFrom(const CodeGeneratorResponse_File& from) {
 767   GOOGLE_CHECK_NE(&from, this);
 768   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
 769     if (from.has_name()) {
 770       set_name(from.name());
 771     }
 772     if (from.has_insertion_point()) {
 773       set_insertion_point(from.insertion_point());
 774     }
 775     if (from.has_content()) {
 776       set_content(from.content());
 777     }
 778   }
 779   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 780 }
 781
 782 void CodeGeneratorResponse_File::CopyFrom(const ::google::protobuf::Message& from) {
 783   if (&from == this) return;
 784   Clear();
 785   MergeFrom(from);
 786 }
 787
 788 void CodeGeneratorResponse_File::CopyFrom(const CodeGeneratorResponse_File& from) {
 789   if (&from == this) return;
 790   Clear();
 791   MergeFrom(from);
 792 }
 793
 794 bool CodeGeneratorResponse_File::IsInitialized() const {
 795
 796   return true;
 797 }
 798
 799 void CodeGeneratorResponse_File::Swap(CodeGeneratorResponse_File* other) {
 800   if (other != this) {
 801     std::swap(name_, other->name_);
 802     std::swap(insertion_point_, other->insertion_point_);
 803     std::swap(content_, other->content_);
 804     std::swap(_has_bits_[0], other->_has_bits_[0]);
 805     _unknown_fields_.Swap(&other->_unknown_fields_);
 806     std::swap(_cached_size_, other->_cached_size_);
 807   }
 808 }
 809
 810 ::google::protobuf::Metadata CodeGeneratorResponse_File::GetMetadata() const {
 811   protobuf_AssignDescriptorsOnce();
 812   ::google::protobuf::Metadata metadata;
 813   metadata.descriptor = CodeGeneratorResponse_File_descriptor_;
 814   metadata.reflection = CodeGeneratorResponse_File_reflection_;
 815   return metadata;
 816 }
 817
 818
 819 // -------------------------------------------------------------------
 820
 821 #ifndef _MSC_VER
 822 const int CodeGeneratorResponse::kErrorFieldNumber;
 823 const int CodeGeneratorResponse::kFileFieldNumber;
 824 #endif  // !_MSC_VER
 825
 826 CodeGeneratorResponse::CodeGeneratorResponse()
 827   : ::google::protobuf::Message() {
 828   SharedCtor();
 829 }
 830
 831 void CodeGeneratorResponse::InitAsDefaultInstance() {
 832 }
 833
 834 CodeGeneratorResponse::CodeGeneratorResponse(const CodeGeneratorResponse& from)
 835   : ::google::protobuf::Message() {
 836   SharedCtor();
 837   MergeFrom(from);
 838 }
 839
 840 void CodeGeneratorResponse::SharedCtor() {
 841   _cached_size_ = 0;
 842   error_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 843   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 844 }
 845
 846 CodeGeneratorResponse::~CodeGeneratorResponse() {
 847   SharedDtor();
 848 }
 849
 850 void CodeGeneratorResponse::SharedDtor() {
 851   if (error_ != &::google::protobuf::internal::kEmptyString) {
 852     delete error_;
 853   }
 854   if (this != default_instance_) {
 855   }
 856 }
 857
 858 void CodeGeneratorResponse::SetCachedSize(int size) const {
 859   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
 860   _cached_size_ = size;
 861   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 862 }
 863 const ::google::protobuf::Descriptor* CodeGeneratorResponse::descriptor() {
 864   protobuf_AssignDescriptorsOnce();
 865   return CodeGeneratorResponse_descriptor_;
 866 }
 867
 868 const CodeGeneratorResponse& CodeGeneratorResponse::default_instance() {
 869   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
 870   return *default_instance_;
 871 }
 872
 873 CodeGeneratorResponse* CodeGeneratorResponse::default_instance_ = NULL;
 874
 875 CodeGeneratorResponse* CodeGeneratorResponse::New() const {
 876   return new CodeGeneratorResponse;
 877 }
 878
 879 void CodeGeneratorResponse::Clear() {
 880   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
 881     if (has_error()) {
 882       if (error_ != &::google::protobuf::internal::kEmptyString) {
 883         error_->clear();
 884       }
 885     }
 886   }
 887   file_.Clear();
 888   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 889   mutable_unknown_fields()->Clear();
 890 }
 891
 892 bool CodeGeneratorResponse::MergePartialFromCodedStream(
 893     ::google::protobuf::io::CodedInputStream* input) {
 894 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
 895   ::google::protobuf::uint32 tag;
 896   while ((tag = input->ReadTag()) != 0) {
 897     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
 898       // optional string error = 1;
 899       case 1: {
 900         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 901             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 902           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
 903                 input, this->mutable_error()));
 904           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 905             this->error().data(), this->error().length(),
 906             ::google::protobuf::internal::WireFormat::PARSE);
 907         } else {
 908           goto handle_uninterpreted;
 909         }
 910         if (input->ExpectTag(122)) goto parse_file;
 911         break;
 912       }
 913
 914       // repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
 915       case 15: {
 916         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 917             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 918          parse_file:
 919           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
 920                 input, add_file()));
 921         } else {
 922           goto handle_uninterpreted;
 923         }
 924         if (input->ExpectTag(122)) goto parse_file;
 925         if (input->ExpectAtEnd()) return true;
 926         break;
 927       }
 928
 929       default: {
 930       handle_uninterpreted:
 931         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 932             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
 933           return true;
 934         }
 935         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
 936               input, tag, mutable_unknown_fields()));
 937         break;
 938       }
 939     }
 940   }
 941   return true;
 942 #undef DO_
 943 }
 944
 945 void CodeGeneratorResponse::SerializeWithCachedSizes(
 946     ::google::protobuf::io::CodedOutputStream* output) const {
 947   // optional string error = 1;
 948   if (has_error()) {
 949     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 950       this->error().data(), this->error().length(),
 951       ::google::protobuf::internal::WireFormat::SERIALIZE);
 952     ::google::protobuf::internal::WireFormatLite::WriteString(
 953       1, this->error(), output);
 954   }
 955
 956   // repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
 957   for (int i = 0; i < this->file_size(); i++) {
 958     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
 959       15, this->file(i), output);
 960   }
 961
 962   if (!unknown_fields().empty()) {
 963     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
 964         unknown_fields(), output);
 965   }
 966 }
 967
 968 ::google::protobuf::uint8* CodeGeneratorResponse::SerializeWithCachedSizesToArray(
 969     ::google::protobuf::uint8* target) const {
 970   // optional string error = 1;
 971   if (has_error()) {
 972     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 973       this->error().data(), this->error().length(),
 974       ::google::protobuf::internal::WireFormat::SERIALIZE);
 975     target =
 976       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
 977         1, this->error(), target);
 978   }
 979
 980   // repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
 981   for (int i = 0; i < this->file_size(); i++) {
 982     target = ::google::protobuf::internal::WireFormatLite::
 983       WriteMessageNoVirtualToArray(
 984         15, this->file(i), target);
 985   }
 986
 987   if (!unknown_fields().empty()) {
 988     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
 989         unknown_fields(), target);
 990   }
 991   return target;
 992 }
 993
 994 int CodeGeneratorResponse::ByteSize() const {
 995   int total_size = 0;
 996
 997   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
 998     // optional string error = 1;
 999     if (has_error()) {
1000       total_size += 1 +
1001         ::google::protobuf::internal::WireFormatLite::StringSize(
1002           this->error());
1003     }
1004
1005   }
1006   // repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
1007   total_size += 1 * this->file_size();
1008   for (int i = 0; i < this->file_size(); i++) {
1009     total_size +=
1010       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1011         this->file(i));
1012   }
1013
1014   if (!unknown_fields().empty()) {
1015     total_size +=
1016       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
1017         unknown_fields());
1018   }
1019   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1020   _cached_size_ = total_size;
1021   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1022   return total_size;
1023 }
1024
1025 void CodeGeneratorResponse::MergeFrom(const ::google::protobuf::Message& from) {
1026   GOOGLE_CHECK_NE(&from, this);
1027   const CodeGeneratorResponse* source =
1028     ::google::protobuf::internal::dynamic_cast_if_available<const CodeGeneratorResponse*>(
1029       &from);
1030   if (source == NULL) {
1031     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1032   } else {
1033     MergeFrom(*source);
1034   }
1035 }
1036
1037 void CodeGeneratorResponse::MergeFrom(const CodeGeneratorResponse& from) {
1038   GOOGLE_CHECK_NE(&from, this);
1039   file_.MergeFrom(from.file_);
1040   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1041     if (from.has_error()) {
1042       set_error(from.error());
1043     }
1044   }
1045   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
1046 }
1047
1048 void CodeGeneratorResponse::CopyFrom(const ::google::protobuf::Message& from) {
1049   if (&from == this) return;
1050   Clear();
1051   MergeFrom(from);
1052 }
1053
1054 void CodeGeneratorResponse::CopyFrom(const CodeGeneratorResponse& from) {
1055   if (&from == this) return;
1056   Clear();
1057   MergeFrom(from);
1058 }
1059
1060 bool CodeGeneratorResponse::IsInitialized() const {
1061
1062   return true;
1063 }
1064
1065 void CodeGeneratorResponse::Swap(CodeGeneratorResponse* other) {
1066   if (other != this) {
1067     std::swap(error_, other->error_);
1068     file_.Swap(&other->file_);
1069     std::swap(_has_bits_[0], other->_has_bits_[0]);
1070     _unknown_fields_.Swap(&other->_unknown_fields_);
1071     std::swap(_cached_size_, other->_cached_size_);
1072   }
1073 }
1074
1075 ::google::protobuf::Metadata CodeGeneratorResponse::GetMetadata() const {
1076   protobuf_AssignDescriptorsOnce();
1077   ::google::protobuf::Metadata metadata;
1078   metadata.descriptor = CodeGeneratorResponse_descriptor_;
1079   metadata.reflection = CodeGeneratorResponse_reflection_;
1080   return metadata;
1081 }
1082
1083
1084 // @@protoc_insertion_point(namespace_scope)
1085
1086 }  // namespace compiler
1087 }  // namespace protobuf
1088 }  // namespace google
1089
1090 // @@protoc_insertion_point(global_scope)