Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(244)

Side by Side Diff: third_party/protobuf/ruby/ext/google/protobuf_c/protobuf.h

Issue 1842653006: Update //third_party/protobuf to version 3. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: merge Created 4 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(Empty)
1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2014 Google Inc. All rights reserved.
3 // https://developers.google.com/protocol-buffers/
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 // * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 // * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the
14 // distribution.
15 // * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31 #ifndef __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__
32 #define __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__
33
34 #include <ruby/ruby.h>
35 #include <ruby/vm.h>
36 #include <ruby/encoding.h>
37
38 #include "upb.h"
39
40 // Forward decls.
41 struct DescriptorPool;
42 struct Descriptor;
43 struct FieldDescriptor;
44 struct EnumDescriptor;
45 struct MessageLayout;
46 struct MessageField;
47 struct MessageHeader;
48 struct MessageBuilderContext;
49 struct EnumBuilderContext;
50 struct Builder;
51
52 typedef struct DescriptorPool DescriptorPool;
53 typedef struct Descriptor Descriptor;
54 typedef struct FieldDescriptor FieldDescriptor;
55 typedef struct OneofDescriptor OneofDescriptor;
56 typedef struct EnumDescriptor EnumDescriptor;
57 typedef struct MessageLayout MessageLayout;
58 typedef struct MessageField MessageField;
59 typedef struct MessageHeader MessageHeader;
60 typedef struct MessageBuilderContext MessageBuilderContext;
61 typedef struct OneofBuilderContext OneofBuilderContext;
62 typedef struct EnumBuilderContext EnumBuilderContext;
63 typedef struct Builder Builder;
64
65 /*
66 It can be a bit confusing how the C structs defined below and the Ruby
67 objects interact and hold references to each other. First, a few principles:
68
69 - Ruby's "TypedData" abstraction lets a Ruby VALUE hold a pointer to a C
70 struct (or arbitrary memory chunk), own it, and free it when collected.
71 Thus, each struct below will have a corresponding Ruby object
72 wrapping/owning it.
73
74 - To get back from an underlying upb {msg,enum}def to the Ruby object, we
75 keep a global hashmap, accessed by get_def_obj/add_def_obj below.
76
77 The in-memory structure is then something like:
78
79 Ruby | upb
80 |
81 DescriptorPool ------------|-----------> upb_symtab____________________
82 | | (message types) \
83 | v \
84 Descriptor ---------------|-----------> upb_msgdef (enum types)|
85 |--> msgclass | | ^ |
86 | (dynamically built) | | | (submsg fields) |
87 |--> MessageLayout | | | /
88 |--------------------------|> decoder method| | /
89 \--------------------------|> serialize | | /
90 | handlers v | /
91 FieldDescriptor -----------|-----------> upb_fielddef /
92 | | /
93 | v (enum fields) /
94 EnumDescriptor ------------|-----------> upb_enumdef <----------'
95 |
96 |
97 ^ | \___/
98 `---------------|-----------------' (get_def_obj map)
99 */
100
101 // -----------------------------------------------------------------------------
102 // Ruby class structure definitions.
103 // -----------------------------------------------------------------------------
104
105 struct DescriptorPool {
106 upb_symtab* symtab;
107 };
108
109 struct Descriptor {
110 const upb_msgdef* msgdef;
111 MessageLayout* layout;
112 VALUE klass; // begins as nil
113 const upb_handlers* fill_handlers;
114 const upb_pbdecodermethod* fill_method;
115 const upb_handlers* pb_serialize_handlers;
116 const upb_handlers* json_serialize_handlers;
117 // Handlers hold type class references for sub-message fields directly in some
118 // cases. We need to keep these rooted because they might otherwise be
119 // collected.
120 VALUE typeclass_references;
121 };
122
123 struct FieldDescriptor {
124 const upb_fielddef* fielddef;
125 };
126
127 struct OneofDescriptor {
128 const upb_oneofdef* oneofdef;
129 };
130
131 struct EnumDescriptor {
132 const upb_enumdef* enumdef;
133 VALUE module; // begins as nil
134 };
135
136 struct MessageBuilderContext {
137 VALUE descriptor;
138 VALUE builder;
139 };
140
141 struct OneofBuilderContext {
142 VALUE descriptor;
143 VALUE builder;
144 };
145
146 struct EnumBuilderContext {
147 VALUE enumdesc;
148 };
149
150 struct Builder {
151 VALUE pending_list;
152 upb_def** defs; // used only while finalizing
153 };
154
155 extern VALUE cDescriptorPool;
156 extern VALUE cDescriptor;
157 extern VALUE cFieldDescriptor;
158 extern VALUE cEnumDescriptor;
159 extern VALUE cMessageBuilderContext;
160 extern VALUE cOneofBuilderContext;
161 extern VALUE cEnumBuilderContext;
162 extern VALUE cBuilder;
163
164 extern VALUE cError;
165 extern VALUE cParseError;
166
167 // We forward-declare all of the Ruby method implementations here because we
168 // sometimes call the methods directly across .c files, rather than going
169 // through Ruby's method dispatching (e.g. during message parse). It's cleaner
170 // to keep the list of object methods together than to split them between
171 // static-in-file definitions and header declarations.
172
173 void DescriptorPool_mark(void* _self);
174 void DescriptorPool_free(void* _self);
175 VALUE DescriptorPool_alloc(VALUE klass);
176 void DescriptorPool_register(VALUE module);
177 DescriptorPool* ruby_to_DescriptorPool(VALUE value);
178 VALUE DescriptorPool_add(VALUE _self, VALUE def);
179 VALUE DescriptorPool_build(VALUE _self);
180 VALUE DescriptorPool_lookup(VALUE _self, VALUE name);
181 VALUE DescriptorPool_generated_pool(VALUE _self);
182
183 void Descriptor_mark(void* _self);
184 void Descriptor_free(void* _self);
185 VALUE Descriptor_alloc(VALUE klass);
186 void Descriptor_register(VALUE module);
187 Descriptor* ruby_to_Descriptor(VALUE value);
188 VALUE Descriptor_name(VALUE _self);
189 VALUE Descriptor_name_set(VALUE _self, VALUE str);
190 VALUE Descriptor_each(VALUE _self);
191 VALUE Descriptor_lookup(VALUE _self, VALUE name);
192 VALUE Descriptor_add_field(VALUE _self, VALUE obj);
193 VALUE Descriptor_add_oneof(VALUE _self, VALUE obj);
194 VALUE Descriptor_each_oneof(VALUE _self);
195 VALUE Descriptor_lookup_oneof(VALUE _self, VALUE name);
196 VALUE Descriptor_msgclass(VALUE _self);
197 extern const rb_data_type_t _Descriptor_type;
198
199 void FieldDescriptor_mark(void* _self);
200 void FieldDescriptor_free(void* _self);
201 VALUE FieldDescriptor_alloc(VALUE klass);
202 void FieldDescriptor_register(VALUE module);
203 FieldDescriptor* ruby_to_FieldDescriptor(VALUE value);
204 VALUE FieldDescriptor_name(VALUE _self);
205 VALUE FieldDescriptor_name_set(VALUE _self, VALUE str);
206 VALUE FieldDescriptor_type(VALUE _self);
207 VALUE FieldDescriptor_type_set(VALUE _self, VALUE type);
208 VALUE FieldDescriptor_label(VALUE _self);
209 VALUE FieldDescriptor_label_set(VALUE _self, VALUE label);
210 VALUE FieldDescriptor_number(VALUE _self);
211 VALUE FieldDescriptor_number_set(VALUE _self, VALUE number);
212 VALUE FieldDescriptor_submsg_name(VALUE _self);
213 VALUE FieldDescriptor_submsg_name_set(VALUE _self, VALUE value);
214 VALUE FieldDescriptor_subtype(VALUE _self);
215 VALUE FieldDescriptor_get(VALUE _self, VALUE msg_rb);
216 VALUE FieldDescriptor_set(VALUE _self, VALUE msg_rb, VALUE value);
217 upb_fieldtype_t ruby_to_fieldtype(VALUE type);
218 VALUE fieldtype_to_ruby(upb_fieldtype_t type);
219
220 void OneofDescriptor_mark(void* _self);
221 void OneofDescriptor_free(void* _self);
222 VALUE OneofDescriptor_alloc(VALUE klass);
223 void OneofDescriptor_register(VALUE module);
224 OneofDescriptor* ruby_to_OneofDescriptor(VALUE value);
225 VALUE OneofDescriptor_name(VALUE _self);
226 VALUE OneofDescriptor_name_set(VALUE _self, VALUE value);
227 VALUE OneofDescriptor_add_field(VALUE _self, VALUE field);
228 VALUE OneofDescriptor_each(VALUE _self, VALUE field);
229
230 void EnumDescriptor_mark(void* _self);
231 void EnumDescriptor_free(void* _self);
232 VALUE EnumDescriptor_alloc(VALUE klass);
233 void EnumDescriptor_register(VALUE module);
234 EnumDescriptor* ruby_to_EnumDescriptor(VALUE value);
235 VALUE EnumDescriptor_name(VALUE _self);
236 VALUE EnumDescriptor_name_set(VALUE _self, VALUE str);
237 VALUE EnumDescriptor_add_value(VALUE _self, VALUE name, VALUE number);
238 VALUE EnumDescriptor_lookup_name(VALUE _self, VALUE name);
239 VALUE EnumDescriptor_lookup_value(VALUE _self, VALUE number);
240 VALUE EnumDescriptor_each(VALUE _self);
241 VALUE EnumDescriptor_enummodule(VALUE _self);
242 extern const rb_data_type_t _EnumDescriptor_type;
243
244 void MessageBuilderContext_mark(void* _self);
245 void MessageBuilderContext_free(void* _self);
246 VALUE MessageBuilderContext_alloc(VALUE klass);
247 void MessageBuilderContext_register(VALUE module);
248 MessageBuilderContext* ruby_to_MessageBuilderContext(VALUE value);
249 VALUE MessageBuilderContext_initialize(VALUE _self,
250 VALUE descriptor,
251 VALUE builder);
252 VALUE MessageBuilderContext_optional(int argc, VALUE* argv, VALUE _self);
253 VALUE MessageBuilderContext_required(int argc, VALUE* argv, VALUE _self);
254 VALUE MessageBuilderContext_repeated(int argc, VALUE* argv, VALUE _self);
255 VALUE MessageBuilderContext_map(int argc, VALUE* argv, VALUE _self);
256 VALUE MessageBuilderContext_oneof(VALUE _self, VALUE name);
257
258 void OneofBuilderContext_mark(void* _self);
259 void OneofBuilderContext_free(void* _self);
260 VALUE OneofBuilderContext_alloc(VALUE klass);
261 void OneofBuilderContext_register(VALUE module);
262 OneofBuilderContext* ruby_to_OneofBuilderContext(VALUE value);
263 VALUE OneofBuilderContext_initialize(VALUE _self,
264 VALUE descriptor,
265 VALUE builder);
266 VALUE OneofBuilderContext_optional(int argc, VALUE* argv, VALUE _self);
267
268 void EnumBuilderContext_mark(void* _self);
269 void EnumBuilderContext_free(void* _self);
270 VALUE EnumBuilderContext_alloc(VALUE klass);
271 void EnumBuilderContext_register(VALUE module);
272 EnumBuilderContext* ruby_to_EnumBuilderContext(VALUE value);
273 VALUE EnumBuilderContext_initialize(VALUE _self, VALUE enumdesc);
274 VALUE EnumBuilderContext_value(VALUE _self, VALUE name, VALUE number);
275
276 void Builder_mark(void* _self);
277 void Builder_free(void* _self);
278 VALUE Builder_alloc(VALUE klass);
279 void Builder_register(VALUE module);
280 Builder* ruby_to_Builder(VALUE value);
281 VALUE Builder_add_message(VALUE _self, VALUE name);
282 VALUE Builder_add_enum(VALUE _self, VALUE name);
283 VALUE Builder_finalize_to_pool(VALUE _self, VALUE pool_rb);
284
285 // -----------------------------------------------------------------------------
286 // Native slot storage abstraction.
287 // -----------------------------------------------------------------------------
288
289 #define NATIVE_SLOT_MAX_SIZE sizeof(uint64_t)
290
291 size_t native_slot_size(upb_fieldtype_t type);
292 void native_slot_set(upb_fieldtype_t type,
293 VALUE type_class,
294 void* memory,
295 VALUE value);
296 // Atomically (with respect to Ruby VM calls) either update the value and set a
297 // oneof case, or do neither. If |case_memory| is null, then no case value is
298 // set.
299 void native_slot_set_value_and_case(upb_fieldtype_t type,
300 VALUE type_class,
301 void* memory,
302 VALUE value,
303 uint32_t* case_memory,
304 uint32_t case_number);
305 VALUE native_slot_get(upb_fieldtype_t type,
306 VALUE type_class,
307 const void* memory);
308 void native_slot_init(upb_fieldtype_t type, void* memory);
309 void native_slot_mark(upb_fieldtype_t type, void* memory);
310 void native_slot_dup(upb_fieldtype_t type, void* to, void* from);
311 void native_slot_deep_copy(upb_fieldtype_t type, void* to, void* from);
312 bool native_slot_eq(upb_fieldtype_t type, void* mem1, void* mem2);
313
314 void native_slot_validate_string_encoding(upb_fieldtype_t type, VALUE value);
315 void native_slot_check_int_range_precision(upb_fieldtype_t type, VALUE value);
316
317 extern rb_encoding* kRubyStringUtf8Encoding;
318 extern rb_encoding* kRubyStringASCIIEncoding;
319 extern rb_encoding* kRubyString8bitEncoding;
320
321 VALUE field_type_class(const upb_fielddef* field);
322
323 #define MAP_KEY_FIELD 1
324 #define MAP_VALUE_FIELD 2
325
326 // Oneof case slot value to indicate that no oneof case is set. The value `0` is
327 // safe because field numbers are used as case identifiers, and no field can
328 // have a number of 0.
329 #define ONEOF_CASE_NONE 0
330
331 // These operate on a map field (i.e., a repeated field of submessages whose
332 // submessage type is a map-entry msgdef).
333 bool is_map_field(const upb_fielddef* field);
334 const upb_fielddef* map_field_key(const upb_fielddef* field);
335 const upb_fielddef* map_field_value(const upb_fielddef* field);
336
337 // These operate on a map-entry msgdef.
338 const upb_fielddef* map_entry_key(const upb_msgdef* msgdef);
339 const upb_fielddef* map_entry_value(const upb_msgdef* msgdef);
340
341 // -----------------------------------------------------------------------------
342 // Repeated field container type.
343 // -----------------------------------------------------------------------------
344
345 typedef struct {
346 upb_fieldtype_t field_type;
347 VALUE field_type_class;
348 void* elements;
349 int size;
350 int capacity;
351 } RepeatedField;
352
353 void RepeatedField_mark(void* self);
354 void RepeatedField_free(void* self);
355 VALUE RepeatedField_alloc(VALUE klass);
356 VALUE RepeatedField_init(int argc, VALUE* argv, VALUE self);
357 void RepeatedField_register(VALUE module);
358
359 extern const rb_data_type_t RepeatedField_type;
360 extern VALUE cRepeatedField;
361
362 RepeatedField* ruby_to_RepeatedField(VALUE value);
363
364 VALUE RepeatedField_each(VALUE _self);
365 VALUE RepeatedField_index(int argc, VALUE* argv, VALUE _self);
366 void* RepeatedField_index_native(VALUE _self, int index);
367 VALUE RepeatedField_index_set(VALUE _self, VALUE _index, VALUE val);
368 void RepeatedField_reserve(RepeatedField* self, int new_size);
369 VALUE RepeatedField_push(VALUE _self, VALUE val);
370 void RepeatedField_push_native(VALUE _self, void* data);
371 VALUE RepeatedField_pop_one(VALUE _self);
372 VALUE RepeatedField_insert(int argc, VALUE* argv, VALUE _self);
373 VALUE RepeatedField_replace(VALUE _self, VALUE list);
374 VALUE RepeatedField_clear(VALUE _self);
375 VALUE RepeatedField_length(VALUE _self);
376 VALUE RepeatedField_dup(VALUE _self);
377 VALUE RepeatedField_deep_copy(VALUE _self);
378 VALUE RepeatedField_to_ary(VALUE _self);
379 VALUE RepeatedField_eq(VALUE _self, VALUE _other);
380 VALUE RepeatedField_hash(VALUE _self);
381 VALUE RepeatedField_inspect(VALUE _self);
382 VALUE RepeatedField_plus(VALUE _self, VALUE list);
383
384 // Defined in repeated_field.c; also used by Map.
385 void validate_type_class(upb_fieldtype_t type, VALUE klass);
386
387 // -----------------------------------------------------------------------------
388 // Map container type.
389 // -----------------------------------------------------------------------------
390
391 typedef struct {
392 upb_fieldtype_t key_type;
393 upb_fieldtype_t value_type;
394 VALUE value_type_class;
395 upb_strtable table;
396 } Map;
397
398 void Map_mark(void* self);
399 void Map_free(void* self);
400 VALUE Map_alloc(VALUE klass);
401 VALUE Map_init(int argc, VALUE* argv, VALUE self);
402 void Map_register(VALUE module);
403
404 extern const rb_data_type_t Map_type;
405 extern VALUE cMap;
406
407 Map* ruby_to_Map(VALUE value);
408
409 VALUE Map_each(VALUE _self);
410 VALUE Map_keys(VALUE _self);
411 VALUE Map_values(VALUE _self);
412 VALUE Map_index(VALUE _self, VALUE key);
413 VALUE Map_index_set(VALUE _self, VALUE key, VALUE value);
414 VALUE Map_has_key(VALUE _self, VALUE key);
415 VALUE Map_delete(VALUE _self, VALUE key);
416 VALUE Map_clear(VALUE _self);
417 VALUE Map_length(VALUE _self);
418 VALUE Map_dup(VALUE _self);
419 VALUE Map_deep_copy(VALUE _self);
420 VALUE Map_eq(VALUE _self, VALUE _other);
421 VALUE Map_hash(VALUE _self);
422 VALUE Map_inspect(VALUE _self);
423 VALUE Map_merge(VALUE _self, VALUE hashmap);
424 VALUE Map_merge_into_self(VALUE _self, VALUE hashmap);
425
426 typedef struct {
427 Map* self;
428 upb_strtable_iter it;
429 } Map_iter;
430
431 void Map_begin(VALUE _self, Map_iter* iter);
432 void Map_next(Map_iter* iter);
433 bool Map_done(Map_iter* iter);
434 VALUE Map_iter_key(Map_iter* iter);
435 VALUE Map_iter_value(Map_iter* iter);
436
437 // -----------------------------------------------------------------------------
438 // Message layout / storage.
439 // -----------------------------------------------------------------------------
440
441 #define MESSAGE_FIELD_NO_CASE ((size_t)-1)
442
443 struct MessageField {
444 size_t offset;
445 size_t case_offset; // for oneofs, a uint32. Else, MESSAGE_FIELD_NO_CASE.
446 };
447
448 struct MessageLayout {
449 const upb_msgdef* msgdef;
450 MessageField* fields;
451 size_t size;
452 };
453
454 MessageLayout* create_layout(const upb_msgdef* msgdef);
455 void free_layout(MessageLayout* layout);
456 VALUE layout_get(MessageLayout* layout,
457 const void* storage,
458 const upb_fielddef* field);
459 void layout_set(MessageLayout* layout,
460 void* storage,
461 const upb_fielddef* field,
462 VALUE val);
463 void layout_init(MessageLayout* layout, void* storage);
464 void layout_mark(MessageLayout* layout, void* storage);
465 void layout_dup(MessageLayout* layout, void* to, void* from);
466 void layout_deep_copy(MessageLayout* layout, void* to, void* from);
467 VALUE layout_eq(MessageLayout* layout, void* msg1, void* msg2);
468 VALUE layout_hash(MessageLayout* layout, void* storage);
469 VALUE layout_inspect(MessageLayout* layout, void* storage);
470
471 // -----------------------------------------------------------------------------
472 // Message class creation.
473 // -----------------------------------------------------------------------------
474
475 struct MessageHeader {
476 Descriptor* descriptor; // kept alive by self.class.descriptor reference.
477 // Data comes after this.
478 };
479
480 extern rb_data_type_t Message_type;
481
482 VALUE build_class_from_descriptor(Descriptor* descriptor);
483 void* Message_data(void* msg);
484 void Message_mark(void* self);
485 void Message_free(void* self);
486 VALUE Message_alloc(VALUE klass);
487 VALUE Message_method_missing(int argc, VALUE* argv, VALUE _self);
488 VALUE Message_initialize(int argc, VALUE* argv, VALUE _self);
489 VALUE Message_dup(VALUE _self);
490 VALUE Message_deep_copy(VALUE _self);
491 VALUE Message_eq(VALUE _self, VALUE _other);
492 VALUE Message_hash(VALUE _self);
493 VALUE Message_inspect(VALUE _self);
494 VALUE Message_index(VALUE _self, VALUE field_name);
495 VALUE Message_index_set(VALUE _self, VALUE field_name, VALUE value);
496 VALUE Message_descriptor(VALUE klass);
497 VALUE Message_decode(VALUE klass, VALUE data);
498 VALUE Message_encode(VALUE klass, VALUE msg_rb);
499 VALUE Message_decode_json(VALUE klass, VALUE data);
500 VALUE Message_encode_json(VALUE klass, VALUE msg_rb);
501
502 VALUE Google_Protobuf_deep_copy(VALUE self, VALUE obj);
503
504 VALUE build_module_from_enumdesc(EnumDescriptor* enumdef);
505 VALUE enum_lookup(VALUE self, VALUE number);
506 VALUE enum_resolve(VALUE self, VALUE sym);
507
508 const upb_pbdecodermethod *new_fillmsg_decodermethod(
509 Descriptor* descriptor, const void *owner);
510
511 // Maximum depth allowed during encoding, to avoid stack overflows due to
512 // cycles.
513 #define ENCODE_MAX_NESTING 63
514
515 // -----------------------------------------------------------------------------
516 // Global map from upb {msg,enum}defs to wrapper Descriptor/EnumDescriptor
517 // instances.
518 // -----------------------------------------------------------------------------
519 void add_def_obj(const void* def, VALUE value);
520 VALUE get_def_obj(const void* def);
521
522 // -----------------------------------------------------------------------------
523 // Utilities.
524 // -----------------------------------------------------------------------------
525
526 void check_upb_status(const upb_status* status, const char* msg);
527
528 #define CHECK_UPB(code, msg) do { \
529 upb_status status = UPB_STATUS_INIT; \
530 code; \
531 check_upb_status(&status, msg); \
532 } while (0)
533
534 extern ID descriptor_instancevar_interned;
535
536 #endif // __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__
OLDNEW
« no previous file with comments | « third_party/protobuf/ruby/ext/google/protobuf_c/message.c ('k') | third_party/protobuf/ruby/ext/google/protobuf_c/protobuf.c » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698