google-protobuf 3.22.3 → 4.27.3

data/ext/google/protobuf_c/third_party/utf8_range/range2-sse.c

@@ -1,170 +0,0 @@
-/*
- * Process 2x16 bytes in each iteration.
- * Comments removed for brevity. See range-sse.c for details.
- */
-#ifdef __SSE4_1__
-
-#include <stdio.h>
-#include <stdint.h>
-#include <x86intrin.h>
-
-int utf8_naive(const unsigned char *data, int len);
-
-static const int8_t _first_len_tbl[] = {
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3,
-};
-
-static const int8_t _first_range_tbl[] = {
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8,
-};
-
-static const int8_t _range_min_tbl[] = {
-    0x00, 0x80, 0x80, 0x80, 0xA0, 0x80, 0x90, 0x80,
-    0xC2, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F,
-};
-static const int8_t _range_max_tbl[] = {
-    0x7F, 0xBF, 0xBF, 0xBF, 0xBF, 0x9F, 0xBF, 0x8F,
-    0xF4, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-};
-
-static const int8_t _df_ee_tbl[] = {
-    0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0,
-};
-static const int8_t _ef_fe_tbl[] = {
-    0, 3, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-};
-
-/* Return 0 on success, -1 on error */
-int utf8_range2(const unsigned char *data, int len)
-{
-    if (len >= 32) {
-        __m128i prev_input = _mm_set1_epi8(0);
-        __m128i prev_first_len = _mm_set1_epi8(0);
-
-        const __m128i first_len_tbl =
-            _mm_loadu_si128((const __m128i *)_first_len_tbl);
-        const __m128i first_range_tbl =
-            _mm_loadu_si128((const __m128i *)_first_range_tbl);
-        const __m128i range_min_tbl =
-            _mm_loadu_si128((const __m128i *)_range_min_tbl);
-        const __m128i range_max_tbl =
-            _mm_loadu_si128((const __m128i *)_range_max_tbl);
-        const __m128i df_ee_tbl =
-            _mm_loadu_si128((const __m128i *)_df_ee_tbl);
-        const __m128i ef_fe_tbl =
-            _mm_loadu_si128((const __m128i *)_ef_fe_tbl);
-
-        __m128i error = _mm_set1_epi8(0);
-
-        while (len >= 32) {
-            /***************************** block 1 ****************************/
-            const __m128i input_a = _mm_loadu_si128((const __m128i *)data);
-
-            __m128i high_nibbles =
-                _mm_and_si128(_mm_srli_epi16(input_a, 4), _mm_set1_epi8(0x0F));
-
-            __m128i first_len_a = _mm_shuffle_epi8(first_len_tbl, high_nibbles);
-
-            __m128i range_a = _mm_shuffle_epi8(first_range_tbl, high_nibbles);
-
-            range_a = _mm_or_si128(
-                    range_a, _mm_alignr_epi8(first_len_a, prev_first_len, 15));
-
-            __m128i tmp;
-            tmp = _mm_alignr_epi8(first_len_a, prev_first_len, 14);
-            tmp = _mm_subs_epu8(tmp, _mm_set1_epi8(1));
-            range_a = _mm_or_si128(range_a, tmp);
-
-            tmp = _mm_alignr_epi8(first_len_a, prev_first_len, 13);
-            tmp = _mm_subs_epu8(tmp, _mm_set1_epi8(2));
-            range_a = _mm_or_si128(range_a, tmp);
-
-            __m128i shift1, pos, range2;
-            shift1 = _mm_alignr_epi8(input_a, prev_input, 15);
-            pos = _mm_sub_epi8(shift1, _mm_set1_epi8(0xEF));
-            tmp = _mm_subs_epu8(pos, _mm_set1_epi8(0xF0));
-            range2 = _mm_shuffle_epi8(df_ee_tbl, tmp);
-            tmp = _mm_adds_epu8(pos, _mm_set1_epi8(0x70));
-            range2 = _mm_add_epi8(range2, _mm_shuffle_epi8(ef_fe_tbl, tmp));
-
-            range_a = _mm_add_epi8(range_a, range2);
-
-            __m128i minv = _mm_shuffle_epi8(range_min_tbl, range_a);
-            __m128i maxv = _mm_shuffle_epi8(range_max_tbl, range_a);
-
-            tmp = _mm_or_si128(
-                      _mm_cmplt_epi8(input_a, minv),
-                      _mm_cmpgt_epi8(input_a, maxv)
-                  );
-            error = _mm_or_si128(error, tmp);
-
-            /***************************** block 2 ****************************/
-            const __m128i input_b = _mm_loadu_si128((const __m128i *)(data+16));
-
-            high_nibbles =
-                _mm_and_si128(_mm_srli_epi16(input_b, 4), _mm_set1_epi8(0x0F));
-
-            __m128i first_len_b = _mm_shuffle_epi8(first_len_tbl, high_nibbles);
-
-            __m128i range_b = _mm_shuffle_epi8(first_range_tbl, high_nibbles);
-
-            range_b = _mm_or_si128(
-                    range_b, _mm_alignr_epi8(first_len_b, first_len_a, 15));
-
-
-            tmp = _mm_alignr_epi8(first_len_b, first_len_a, 14);
-            tmp = _mm_subs_epu8(tmp, _mm_set1_epi8(1));
-            range_b = _mm_or_si128(range_b, tmp);
-
-            tmp = _mm_alignr_epi8(first_len_b, first_len_a, 13);
-            tmp = _mm_subs_epu8(tmp, _mm_set1_epi8(2));
-            range_b = _mm_or_si128(range_b, tmp);
-
-            shift1 = _mm_alignr_epi8(input_b, input_a, 15);
-            pos = _mm_sub_epi8(shift1, _mm_set1_epi8(0xEF));
-            tmp = _mm_subs_epu8(pos, _mm_set1_epi8(0xF0));
-            range2 = _mm_shuffle_epi8(df_ee_tbl, tmp);
-            tmp = _mm_adds_epu8(pos, _mm_set1_epi8(0x70));
-            range2 = _mm_add_epi8(range2, _mm_shuffle_epi8(ef_fe_tbl, tmp));
-
-            range_b = _mm_add_epi8(range_b, range2);
-
-            minv = _mm_shuffle_epi8(range_min_tbl, range_b);
-            maxv = _mm_shuffle_epi8(range_max_tbl, range_b);
-
-
-            tmp = _mm_or_si128(
-                      _mm_cmplt_epi8(input_b, minv),
-                      _mm_cmpgt_epi8(input_b, maxv)
-                  );
-            error = _mm_or_si128(error, tmp);
-
-            /************************ next iteration **************************/
-            prev_input = input_b;
-            prev_first_len = first_len_b;
-
-            data += 32;
-            len -= 32;
-        }
-
-        if (!_mm_testz_si128(error, error))
-            return -1;
-
-        int32_t token4 = _mm_extract_epi32(prev_input, 3);
-        const int8_t *token = (const int8_t *)&token4;
-        int lookahead = 0;
-        if (token[3] > (int8_t)0xBF)
-            lookahead = 1;
-        else if (token[2] > (int8_t)0xBF)
-            lookahead = 2;
-        else if (token[1] > (int8_t)0xBF)
-            lookahead = 3;
-
-        data -= lookahead;
-        len += lookahead;
-    }
-
-    return utf8_naive(data, len);
-}
-
-#endif

data/lib/google/protobuf/descriptor_dsl.rb

@@ -1,465 +0,0 @@
-#!/usr/bin/ruby
-#
-# Code that implements the DSL for defining proto messages.
-
-# Suppress warning: loading in progress, circular require considered harmful.
-# This circular require is intentional to avoid missing dependency.
-begin
-  old_verbose, $VERBOSE = $VERBOSE, nil
-  require 'google/protobuf/descriptor_pb'
-ensure
-  $VERBOSE = old_verbose
-end
-
-module Google
-  module Protobuf
-    module Internal
-      class AtomicCounter
-        def initialize
-          @n = 0
-          @mu = Mutex.new
-        end
-
-        def get_and_increment
-          n = @n
-          @mu.synchronize {
-            @n += 1
-          }
-          return n
-        end
-      end
-
-      class Builder
-        @@file_number = AtomicCounter.new
-
-        def initialize(pool)
-          @pool = pool
-          @default_file = nil  # Constructed lazily
-        end
-
-        def add_file(name, options={}, &block)
-          builder = FileBuilder.new(@pool, name, options)
-          builder.instance_eval(&block)
-          internal_add_file(builder)
-        end
-
-        def add_message(name, &block)
-          internal_default_file.add_message(name, &block)
-        end
-
-        def add_enum(name, &block)
-          internal_default_file.add_enum(name, &block)
-        end
-
-        # ---- Internal methods, not part of the DSL ----
-
-        def build
-          if @default_file
-            internal_add_file(@default_file)
-          end
-        end
-
-        private def internal_add_file(file_builder)
-          proto = file_builder.build
-          serialized = Google::Protobuf::FileDescriptorProto.encode(proto)
-          @pool.add_serialized_file(serialized)
-        end
-
-        private def internal_default_file
-          number = @@file_number.get_and_increment
-          filename = "ruby_default_file#{number}.proto"
-          @default_file ||= FileBuilder.new(@pool, filename)
-        end
-      end
-
-      class FileBuilder
-        def initialize(pool, name, options={})
-          @pool = pool
-          @file_proto = Google::Protobuf::FileDescriptorProto.new(
-            name: name,
-            syntax: options.fetch(:syntax, "proto3")
-          )
-        end
-
-        def add_message(name, &block)
-          builder = MessageBuilder.new(name, self, @file_proto)
-          builder.instance_eval(&block)
-          builder.internal_add_synthetic_oneofs
-        end
-
-        def add_enum(name, &block)
-          EnumBuilder.new(name, @file_proto).instance_eval(&block)
-        end
-
-        # ---- Internal methods, not part of the DSL ----
-
-        # These methods fix up the file descriptor to account for differences
-        # between the DSL and FileDescriptorProto.
-
-        # The DSL can omit a package name; here we infer what the package is if
-        # was not specified.
-        def infer_package(names)
-          # Package is longest common prefix ending in '.', if any.
-          if not names.empty?
-            min, max = names.minmax
-            last_common_dot = nil
-            min.size.times { |i|
-              if min[i] != max[i] then break end
-              if min[i] == "." then last_common_dot = i end
-            }
-            if last_common_dot
-              return min.slice(0, last_common_dot)
-            end
-          end
-
-          nil
-        end
-
-        def rewrite_enum_default(field)
-          if field.type != :TYPE_ENUM or !field.has_default_value? or !field.has_type_name?
-            return
-          end
-
-          value = field.default_value
-          type_name = field.type_name
-
-          if value.empty? or value[0].ord < "0".ord or value[0].ord > "9".ord
-            return
-          end
-
-          if type_name.empty? || type_name[0] != "."
-            return
-          end
-
-          type_name = type_name[1..-1]
-          as_int = Integer(value) rescue return
-
-          enum_desc = @pool.lookup(type_name)
-          if enum_desc.is_a?(Google::Protobuf::EnumDescriptor)
-            # Enum was defined in a previous file.
-            name = enum_desc.lookup_value(as_int)
-            if name
-              # Update the default value in the proto.
-              field.default_value = name
-            end
-          else
-            # See if enum was defined in this file.
-            @file_proto.enum_type.each { |enum_proto|
-              if enum_proto.name == type_name
-                enum_proto.value.each { |enum_value_proto|
-                  if enum_value_proto.number == as_int
-                    # Update the default value in the proto.
-                    field.default_value = enum_value_proto.name
-                    return
-                  end
-                }
-                # We found the right enum, but no value matched.
-                return
-              end
-            }
-          end
-        end
-
-        # Historically we allowed enum defaults to be specified as a number.
-        # In retrospect this was a mistake as descriptors require defaults to
-        # be specified as a label. This can make a difference if multiple
-        # labels have the same number.
-        #
-        # Here we do a pass over all enum defaults and rewrite numeric defaults
-        # by looking up their labels.  This is complicated by the fact that the
-        # enum definition can live in either the symtab or the file_proto.
-        #
-        # We take advantage of the fact that this is called *before* enums or
-        # messages are nested in other messages, so we only have to iterate
-        # one level deep.
-        def rewrite_enum_defaults
-          @file_proto.message_type.each { |msg|
-            msg.field.each { |field|
-              rewrite_enum_default(field)
-            }
-          }
-        end
-
-        # We have to do some relatively complicated logic here for backward
-        # compatibility.
-        #
-        # In descriptor.proto, messages are nested inside other messages if that is
-        # what the original .proto file looks like.  For example, suppose we have this
-        # foo.proto:
-        #
-        # package foo;
-        # message Bar {
-        #   message Baz {}
-        # }
-        #
-        # The descriptor for this must look like this:
-        #
-        # file {
-        #   name: "test.proto"
-        #   package: "foo"
-        #   message_type {
-        #     name: "Bar"
-        #     nested_type {
-        #       name: "Baz"
-        #     }
-        #   }
-        # }
-        #
-        # However, the Ruby generated code has always generated messages in a flat,
-        # non-nested way:
-        #
-        # Google::Protobuf::DescriptorPool.generated_pool.build do
-        #   add_message "foo.Bar" do
-        #   end
-        #   add_message "foo.Bar.Baz" do
-        #   end
-        # end
-        #
-        # Here we need to do a translation where we turn this generated code into the
-        # above descriptor.  We need to infer that "foo" is the package name, and not
-        # a message itself. */
-
-        def split_parent_name(msg_or_enum)
-          name = msg_or_enum.name
-          idx = name.rindex(?.)
-          if idx
-            return name[0...idx], name[idx+1..-1]
-          else
-            return nil, name
-          end
-        end
-
-        def get_parent_msg(msgs_by_name, name, parent_name)
-          parent_msg = msgs_by_name[parent_name]
-          if parent_msg.nil?
-            raise "To define name #{name}, there must be a message named #{parent_name} to enclose it"
-          end
-          return parent_msg
-        end
-
-        def fix_nesting
-          # Calculate and update package.
-          msgs_by_name = @file_proto.message_type.map { |msg| [msg.name, msg] }.to_h
-          enum_names = @file_proto.enum_type.map { |enum_proto| enum_proto.name }
-
-          package = infer_package(msgs_by_name.keys + enum_names)
-          if package
-            @file_proto.package = package
-          end
-
-          # Update nesting based on package.
-          final_msgs = Google::Protobuf::RepeatedField.new(:message, Google::Protobuf::DescriptorProto)
-          final_enums = Google::Protobuf::RepeatedField.new(:message, Google::Protobuf::EnumDescriptorProto)
-
-          # Note: We don't iterate over msgs_by_name.values because we want to
-          # preserve order as listed in the DSL.
-          @file_proto.message_type.each { |msg|
-            parent_name, msg.name = split_parent_name(msg)
-            if parent_name == package
-              final_msgs << msg
-            else
-              get_parent_msg(msgs_by_name, msg.name, parent_name).nested_type << msg
-            end
-          }
-
-          @file_proto.enum_type.each { |enum|
-            parent_name, enum.name = split_parent_name(enum)
-            if parent_name == package
-              final_enums << enum
-            else
-              get_parent_msg(msgs_by_name, enum.name, parent_name).enum_type << enum
-            end
-          }
-
-          @file_proto.message_type = final_msgs
-          @file_proto.enum_type = final_enums
-        end
-
-        def internal_file_proto
-          @file_proto
-        end
-
-        def build
-          rewrite_enum_defaults
-          fix_nesting
-          return @file_proto
-        end
-      end
-
-      class MessageBuilder
-        def initialize(name, file_builder, file_proto)
-          @file_builder = file_builder
-          @msg_proto = Google::Protobuf::DescriptorProto.new(
-            :name => name
-          )
-          file_proto.message_type << @msg_proto
-        end
-
-        def optional(name, type, number, type_class=nil, options=nil)
-          internal_add_field(:LABEL_OPTIONAL, name, type, number, type_class, options)
-        end
-
-        def proto3_optional(name, type, number, type_class=nil, options=nil)
-          internal_add_field(:LABEL_OPTIONAL, name, type, number, type_class, options,
-                             proto3_optional: true)
-        end
-
-        def required(name, type, number, type_class=nil, options=nil)
-          internal_add_field(:LABEL_REQUIRED, name, type, number, type_class, options)
-        end
-
-        def repeated(name, type, number, type_class = nil, options=nil)
-          internal_add_field(:LABEL_REPEATED, name, type, number, type_class, options)
-        end
-
-        def oneof(name, &block)
-          OneofBuilder.new(name, self).instance_eval(&block)
-        end
-
-        # Defines a new map field on this message type with the given key and
-        # value types, tag number, and type class (for message and enum value
-        # types). The key type must be :int32/:uint32/:int64/:uint64, :bool, or
-        # :string. The value type type must be a Ruby symbol (as accepted by
-        # FieldDescriptor#type=) and the type_class must be a string, if
-        # present (as accepted by FieldDescriptor#submsg_name=).
-        def map(name, key_type, value_type, number, value_type_class = nil)
-          if key_type == :float or key_type == :double or key_type == :enum or
-             key_type == :message
-            raise ArgError, "Not an acceptable key type: " + key_type
-          end
-          entry_name = "#{@msg_proto.name}_MapEntry_#{name}"
-
-          @file_builder.add_message entry_name do
-            optional :key, key_type, 1
-            optional :value, value_type, 2, value_type_class
-          end
-          options = @file_builder.internal_file_proto.message_type.last.options ||= MessageOptions.new
-          options.map_entry = true
-          repeated name, :message, number, entry_name
-        end
-
-        # ---- Internal methods, not part of the DSL ----
-
-        def internal_add_synthetic_oneofs
-          # We have to build a set of all names, to ensure that synthetic oneofs
-          # are not creating conflicts
-          names = {}
-          @msg_proto.field.each { |field| names[field.name] = true }
-          @msg_proto.oneof_decl.each { |oneof| names[oneof.name] = true }
-
-          @msg_proto.field.each { |field|
-            if field.proto3_optional
-              # Prepend '_' until we are no longer conflicting.
-              oneof_name = field.name
-              while names[oneof_name]
-                oneof_name = "_" + oneof_name
-              end
-              names[oneof_name] = true
-              field.oneof_index = @msg_proto.oneof_decl.size
-              @msg_proto.oneof_decl << Google::Protobuf::OneofDescriptorProto.new(
-                name: oneof_name
-              )
-            end
-          }
-        end
-
-        def internal_add_field(label, name, type, number, type_class, options,
-                               oneof_index: nil, proto3_optional: false)
-          # Allow passing either:
-          # - (name, type, number, options) or
-          # - (name, type, number, type_class, options)
-          if options.nil? and type_class.instance_of?(Hash)
-            options = type_class;
-            type_class = nil;
-          end
-
-          field_proto = Google::Protobuf::FieldDescriptorProto.new(
-            :label => label,
-            :name => name,
-            :type => ("TYPE_" + type.to_s.upcase).to_sym,
-            :number => number
-          )
-
-          if type_class
-            # Make it an absolute type name by prepending a dot.
-            field_proto.type_name = "." + type_class
-          end
-
-          if oneof_index
-            field_proto.oneof_index = oneof_index
-          end
-
-          if proto3_optional
-            field_proto.proto3_optional = true
-          end
-
-          if options
-            if options.key?(:default)
-              default = options[:default]
-              if !default.instance_of?(String)
-                # Call #to_s since all defaults are strings in the descriptor.
-                default = default.to_s
-              end
-              # XXX: we should be C-escaping bytes defaults.
-              field_proto.default_value = default.dup.force_encoding("UTF-8")
-            end
-            if options.key?(:json_name)
-              field_proto.json_name = options[:json_name]
-            end
-          end
-
-          @msg_proto.field << field_proto
-        end
-
-        def internal_msg_proto
-          @msg_proto
-        end
-      end
-
-      class OneofBuilder
-        def initialize(name, msg_builder)
-          @msg_builder = msg_builder
-          oneof_proto = Google::Protobuf::OneofDescriptorProto.new(
-            :name => name
-          )
-          msg_proto = msg_builder.internal_msg_proto
-          @oneof_index = msg_proto.oneof_decl.size
-          msg_proto.oneof_decl << oneof_proto
-        end
-
-        def optional(name, type, number, type_class=nil, options=nil)
-          @msg_builder.internal_add_field(
-              :LABEL_OPTIONAL, name, type, number, type_class, options,
-              oneof_index: @oneof_index)
-        end
-      end
-
-      class EnumBuilder
-        def initialize(name, file_proto)
-          @enum_proto = Google::Protobuf::EnumDescriptorProto.new(
-            :name => name
-          )
-          file_proto.enum_type << @enum_proto
-        end
-
-        def value(name, number)
-          enum_value_proto = Google::Protobuf::EnumValueDescriptorProto.new(
-            name: name,
-            number: number
-          )
-          @enum_proto.value << enum_value_proto
-        end
-      end
-
-    end
-
-    # Re-open the class (the rest of the class is implemented in C)
-    class DescriptorPool
-      def build(&block)
-        builder = Internal::Builder.new(self)
-        builder.instance_eval(&block)
-        builder.build
-      end
-    end
-  end
-end