Coverage Report

Created: 2024-11-21 06:05

/src/protobuf-c-fuzzers/test-full.pb-c.c
Line
Count
Source (jump to first uncovered line)
1
/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
2
/* Generated from: test-full.proto */
3
4
/* Do not generate deprecated warnings for self */
5
#ifndef PROTOBUF_C__NO_DEPRECATED
6
#define PROTOBUF_C__NO_DEPRECATED
7
#endif
8
9
#include "test-full.pb-c.h"
10
void   foo__sub_mess__sub_sub_mess__init
11
                     (Foo__SubMess__SubSubMess         *message)
12
34.7k
{
13
34.7k
  static const Foo__SubMess__SubSubMess init_value = FOO__SUB_MESS__SUB_SUB_MESS__INIT;
14
34.7k
  *message = init_value;
15
34.7k
}
16
void   foo__sub_mess__init
17
                     (Foo__SubMess         *message)
18
41.6k
{
19
41.6k
  static const Foo__SubMess init_value = FOO__SUB_MESS__INIT;
20
41.6k
  *message = init_value;
21
41.6k
}
22
size_t foo__sub_mess__get_packed_size
23
                     (const Foo__SubMess *message)
24
0
{
25
0
  assert(message->base.descriptor == &foo__sub_mess__descriptor);
26
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
27
0
}
28
size_t foo__sub_mess__pack
29
                     (const Foo__SubMess *message,
30
                      uint8_t       *out)
31
0
{
32
0
  assert(message->base.descriptor == &foo__sub_mess__descriptor);
33
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
34
0
}
35
size_t foo__sub_mess__pack_to_buffer
36
                     (const Foo__SubMess *message,
37
                      ProtobufCBuffer *buffer)
38
0
{
39
0
  assert(message->base.descriptor == &foo__sub_mess__descriptor);
40
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
41
0
}
42
Foo__SubMess *
43
       foo__sub_mess__unpack
44
                     (ProtobufCAllocator  *allocator,
45
                      size_t               len,
46
                      const uint8_t       *data)
47
0
{
48
0
  return (Foo__SubMess *)
49
0
     protobuf_c_message_unpack (&foo__sub_mess__descriptor,
50
0
                                allocator, len, data);
51
0
}
52
void   foo__sub_mess__free_unpacked
53
                     (Foo__SubMess *message,
54
                      ProtobufCAllocator *allocator)
55
0
{
56
0
  if(!message)
57
0
    return;
58
0
  assert(message->base.descriptor == &foo__sub_mess__descriptor);
59
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
60
0
}
61
void   foo__test_field_no15__init
62
                     (Foo__TestFieldNo15         *message)
63
0
{
64
0
  static const Foo__TestFieldNo15 init_value = FOO__TEST_FIELD_NO15__INIT;
65
0
  *message = init_value;
66
0
}
67
size_t foo__test_field_no15__get_packed_size
68
                     (const Foo__TestFieldNo15 *message)
69
0
{
70
0
  assert(message->base.descriptor == &foo__test_field_no15__descriptor);
71
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
72
0
}
73
size_t foo__test_field_no15__pack
74
                     (const Foo__TestFieldNo15 *message,
75
                      uint8_t       *out)
76
0
{
77
0
  assert(message->base.descriptor == &foo__test_field_no15__descriptor);
78
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
79
0
}
80
size_t foo__test_field_no15__pack_to_buffer
81
                     (const Foo__TestFieldNo15 *message,
82
                      ProtobufCBuffer *buffer)
83
0
{
84
0
  assert(message->base.descriptor == &foo__test_field_no15__descriptor);
85
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
86
0
}
87
Foo__TestFieldNo15 *
88
       foo__test_field_no15__unpack
89
                     (ProtobufCAllocator  *allocator,
90
                      size_t               len,
91
                      const uint8_t       *data)
92
0
{
93
0
  return (Foo__TestFieldNo15 *)
94
0
     protobuf_c_message_unpack (&foo__test_field_no15__descriptor,
95
0
                                allocator, len, data);
96
0
}
97
void   foo__test_field_no15__free_unpacked
98
                     (Foo__TestFieldNo15 *message,
99
                      ProtobufCAllocator *allocator)
100
0
{
101
0
  if(!message)
102
0
    return;
103
0
  assert(message->base.descriptor == &foo__test_field_no15__descriptor);
104
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
105
0
}
106
void   foo__test_field_no16__init
107
                     (Foo__TestFieldNo16         *message)
108
0
{
109
0
  static const Foo__TestFieldNo16 init_value = FOO__TEST_FIELD_NO16__INIT;
110
0
  *message = init_value;
111
0
}
112
size_t foo__test_field_no16__get_packed_size
113
                     (const Foo__TestFieldNo16 *message)
114
0
{
115
0
  assert(message->base.descriptor == &foo__test_field_no16__descriptor);
116
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
117
0
}
118
size_t foo__test_field_no16__pack
119
                     (const Foo__TestFieldNo16 *message,
120
                      uint8_t       *out)
121
0
{
122
0
  assert(message->base.descriptor == &foo__test_field_no16__descriptor);
123
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
124
0
}
125
size_t foo__test_field_no16__pack_to_buffer
126
                     (const Foo__TestFieldNo16 *message,
127
                      ProtobufCBuffer *buffer)
128
0
{
129
0
  assert(message->base.descriptor == &foo__test_field_no16__descriptor);
130
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
131
0
}
132
Foo__TestFieldNo16 *
133
       foo__test_field_no16__unpack
134
                     (ProtobufCAllocator  *allocator,
135
                      size_t               len,
136
                      const uint8_t       *data)
137
0
{
138
0
  return (Foo__TestFieldNo16 *)
139
0
     protobuf_c_message_unpack (&foo__test_field_no16__descriptor,
140
0
                                allocator, len, data);
141
0
}
142
void   foo__test_field_no16__free_unpacked
143
                     (Foo__TestFieldNo16 *message,
144
                      ProtobufCAllocator *allocator)
145
0
{
146
0
  if(!message)
147
0
    return;
148
0
  assert(message->base.descriptor == &foo__test_field_no16__descriptor);
149
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
150
0
}
151
void   foo__test_field_no2047__init
152
                     (Foo__TestFieldNo2047         *message)
153
0
{
154
0
  static const Foo__TestFieldNo2047 init_value = FOO__TEST_FIELD_NO2047__INIT;
155
0
  *message = init_value;
156
0
}
157
size_t foo__test_field_no2047__get_packed_size
158
                     (const Foo__TestFieldNo2047 *message)
159
0
{
160
0
  assert(message->base.descriptor == &foo__test_field_no2047__descriptor);
161
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
162
0
}
163
size_t foo__test_field_no2047__pack
164
                     (const Foo__TestFieldNo2047 *message,
165
                      uint8_t       *out)
166
0
{
167
0
  assert(message->base.descriptor == &foo__test_field_no2047__descriptor);
168
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
169
0
}
170
size_t foo__test_field_no2047__pack_to_buffer
171
                     (const Foo__TestFieldNo2047 *message,
172
                      ProtobufCBuffer *buffer)
173
0
{
174
0
  assert(message->base.descriptor == &foo__test_field_no2047__descriptor);
175
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
176
0
}
177
Foo__TestFieldNo2047 *
178
       foo__test_field_no2047__unpack
179
                     (ProtobufCAllocator  *allocator,
180
                      size_t               len,
181
                      const uint8_t       *data)
182
0
{
183
0
  return (Foo__TestFieldNo2047 *)
184
0
     protobuf_c_message_unpack (&foo__test_field_no2047__descriptor,
185
0
                                allocator, len, data);
186
0
}
187
void   foo__test_field_no2047__free_unpacked
188
                     (Foo__TestFieldNo2047 *message,
189
                      ProtobufCAllocator *allocator)
190
0
{
191
0
  if(!message)
192
0
    return;
193
0
  assert(message->base.descriptor == &foo__test_field_no2047__descriptor);
194
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
195
0
}
196
void   foo__test_field_no2048__init
197
                     (Foo__TestFieldNo2048         *message)
198
0
{
199
0
  static const Foo__TestFieldNo2048 init_value = FOO__TEST_FIELD_NO2048__INIT;
200
0
  *message = init_value;
201
0
}
202
size_t foo__test_field_no2048__get_packed_size
203
                     (const Foo__TestFieldNo2048 *message)
204
0
{
205
0
  assert(message->base.descriptor == &foo__test_field_no2048__descriptor);
206
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
207
0
}
208
size_t foo__test_field_no2048__pack
209
                     (const Foo__TestFieldNo2048 *message,
210
                      uint8_t       *out)
211
0
{
212
0
  assert(message->base.descriptor == &foo__test_field_no2048__descriptor);
213
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
214
0
}
215
size_t foo__test_field_no2048__pack_to_buffer
216
                     (const Foo__TestFieldNo2048 *message,
217
                      ProtobufCBuffer *buffer)
218
0
{
219
0
  assert(message->base.descriptor == &foo__test_field_no2048__descriptor);
220
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
221
0
}
222
Foo__TestFieldNo2048 *
223
       foo__test_field_no2048__unpack
224
                     (ProtobufCAllocator  *allocator,
225
                      size_t               len,
226
                      const uint8_t       *data)
227
0
{
228
0
  return (Foo__TestFieldNo2048 *)
229
0
     protobuf_c_message_unpack (&foo__test_field_no2048__descriptor,
230
0
                                allocator, len, data);
231
0
}
232
void   foo__test_field_no2048__free_unpacked
233
                     (Foo__TestFieldNo2048 *message,
234
                      ProtobufCAllocator *allocator)
235
0
{
236
0
  if(!message)
237
0
    return;
238
0
  assert(message->base.descriptor == &foo__test_field_no2048__descriptor);
239
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
240
0
}
241
void   foo__test_field_no262143__init
242
                     (Foo__TestFieldNo262143         *message)
243
0
{
244
0
  static const Foo__TestFieldNo262143 init_value = FOO__TEST_FIELD_NO262143__INIT;
245
0
  *message = init_value;
246
0
}
247
size_t foo__test_field_no262143__get_packed_size
248
                     (const Foo__TestFieldNo262143 *message)
249
0
{
250
0
  assert(message->base.descriptor == &foo__test_field_no262143__descriptor);
251
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
252
0
}
253
size_t foo__test_field_no262143__pack
254
                     (const Foo__TestFieldNo262143 *message,
255
                      uint8_t       *out)
256
0
{
257
0
  assert(message->base.descriptor == &foo__test_field_no262143__descriptor);
258
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
259
0
}
260
size_t foo__test_field_no262143__pack_to_buffer
261
                     (const Foo__TestFieldNo262143 *message,
262
                      ProtobufCBuffer *buffer)
263
0
{
264
0
  assert(message->base.descriptor == &foo__test_field_no262143__descriptor);
265
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
266
0
}
267
Foo__TestFieldNo262143 *
268
       foo__test_field_no262143__unpack
269
                     (ProtobufCAllocator  *allocator,
270
                      size_t               len,
271
                      const uint8_t       *data)
272
0
{
273
0
  return (Foo__TestFieldNo262143 *)
274
0
     protobuf_c_message_unpack (&foo__test_field_no262143__descriptor,
275
0
                                allocator, len, data);
276
0
}
277
void   foo__test_field_no262143__free_unpacked
278
                     (Foo__TestFieldNo262143 *message,
279
                      ProtobufCAllocator *allocator)
280
0
{
281
0
  if(!message)
282
0
    return;
283
0
  assert(message->base.descriptor == &foo__test_field_no262143__descriptor);
284
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
285
0
}
286
void   foo__test_field_no262144__init
287
                     (Foo__TestFieldNo262144         *message)
288
0
{
289
0
  static const Foo__TestFieldNo262144 init_value = FOO__TEST_FIELD_NO262144__INIT;
290
0
  *message = init_value;
291
0
}
292
size_t foo__test_field_no262144__get_packed_size
293
                     (const Foo__TestFieldNo262144 *message)
294
0
{
295
0
  assert(message->base.descriptor == &foo__test_field_no262144__descriptor);
296
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
297
0
}
298
size_t foo__test_field_no262144__pack
299
                     (const Foo__TestFieldNo262144 *message,
300
                      uint8_t       *out)
301
0
{
302
0
  assert(message->base.descriptor == &foo__test_field_no262144__descriptor);
303
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
304
0
}
305
size_t foo__test_field_no262144__pack_to_buffer
306
                     (const Foo__TestFieldNo262144 *message,
307
                      ProtobufCBuffer *buffer)
308
0
{
309
0
  assert(message->base.descriptor == &foo__test_field_no262144__descriptor);
310
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
311
0
}
312
Foo__TestFieldNo262144 *
313
       foo__test_field_no262144__unpack
314
                     (ProtobufCAllocator  *allocator,
315
                      size_t               len,
316
                      const uint8_t       *data)
317
0
{
318
0
  return (Foo__TestFieldNo262144 *)
319
0
     protobuf_c_message_unpack (&foo__test_field_no262144__descriptor,
320
0
                                allocator, len, data);
321
0
}
322
void   foo__test_field_no262144__free_unpacked
323
                     (Foo__TestFieldNo262144 *message,
324
                      ProtobufCAllocator *allocator)
325
0
{
326
0
  if(!message)
327
0
    return;
328
0
  assert(message->base.descriptor == &foo__test_field_no262144__descriptor);
329
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
330
0
}
331
void   foo__test_field_no33554431__init
332
                     (Foo__TestFieldNo33554431         *message)
333
0
{
334
0
  static const Foo__TestFieldNo33554431 init_value = FOO__TEST_FIELD_NO33554431__INIT;
335
0
  *message = init_value;
336
0
}
337
size_t foo__test_field_no33554431__get_packed_size
338
                     (const Foo__TestFieldNo33554431 *message)
339
0
{
340
0
  assert(message->base.descriptor == &foo__test_field_no33554431__descriptor);
341
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
342
0
}
343
size_t foo__test_field_no33554431__pack
344
                     (const Foo__TestFieldNo33554431 *message,
345
                      uint8_t       *out)
346
0
{
347
0
  assert(message->base.descriptor == &foo__test_field_no33554431__descriptor);
348
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
349
0
}
350
size_t foo__test_field_no33554431__pack_to_buffer
351
                     (const Foo__TestFieldNo33554431 *message,
352
                      ProtobufCBuffer *buffer)
353
0
{
354
0
  assert(message->base.descriptor == &foo__test_field_no33554431__descriptor);
355
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
356
0
}
357
Foo__TestFieldNo33554431 *
358
       foo__test_field_no33554431__unpack
359
                     (ProtobufCAllocator  *allocator,
360
                      size_t               len,
361
                      const uint8_t       *data)
362
0
{
363
0
  return (Foo__TestFieldNo33554431 *)
364
0
     protobuf_c_message_unpack (&foo__test_field_no33554431__descriptor,
365
0
                                allocator, len, data);
366
0
}
367
void   foo__test_field_no33554431__free_unpacked
368
                     (Foo__TestFieldNo33554431 *message,
369
                      ProtobufCAllocator *allocator)
370
0
{
371
0
  if(!message)
372
0
    return;
373
0
  assert(message->base.descriptor == &foo__test_field_no33554431__descriptor);
374
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
375
0
}
376
void   foo__test_field_no33554432__init
377
                     (Foo__TestFieldNo33554432         *message)
378
0
{
379
0
  static const Foo__TestFieldNo33554432 init_value = FOO__TEST_FIELD_NO33554432__INIT;
380
0
  *message = init_value;
381
0
}
382
size_t foo__test_field_no33554432__get_packed_size
383
                     (const Foo__TestFieldNo33554432 *message)
384
0
{
385
0
  assert(message->base.descriptor == &foo__test_field_no33554432__descriptor);
386
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
387
0
}
388
size_t foo__test_field_no33554432__pack
389
                     (const Foo__TestFieldNo33554432 *message,
390
                      uint8_t       *out)
391
0
{
392
0
  assert(message->base.descriptor == &foo__test_field_no33554432__descriptor);
393
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
394
0
}
395
size_t foo__test_field_no33554432__pack_to_buffer
396
                     (const Foo__TestFieldNo33554432 *message,
397
                      ProtobufCBuffer *buffer)
398
0
{
399
0
  assert(message->base.descriptor == &foo__test_field_no33554432__descriptor);
400
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
401
0
}
402
Foo__TestFieldNo33554432 *
403
       foo__test_field_no33554432__unpack
404
                     (ProtobufCAllocator  *allocator,
405
                      size_t               len,
406
                      const uint8_t       *data)
407
0
{
408
0
  return (Foo__TestFieldNo33554432 *)
409
0
     protobuf_c_message_unpack (&foo__test_field_no33554432__descriptor,
410
0
                                allocator, len, data);
411
0
}
412
void   foo__test_field_no33554432__free_unpacked
413
                     (Foo__TestFieldNo33554432 *message,
414
                      ProtobufCAllocator *allocator)
415
0
{
416
0
  if(!message)
417
0
    return;
418
0
  assert(message->base.descriptor == &foo__test_field_no33554432__descriptor);
419
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
420
0
}
421
void   foo__test_mess__init
422
                     (Foo__TestMess         *message)
423
48.8k
{
424
48.8k
  static const Foo__TestMess init_value = FOO__TEST_MESS__INIT;
425
48.8k
  *message = init_value;
426
48.8k
}
427
size_t foo__test_mess__get_packed_size
428
                     (const Foo__TestMess *message)
429
0
{
430
0
  assert(message->base.descriptor == &foo__test_mess__descriptor);
431
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
432
0
}
433
size_t foo__test_mess__pack
434
                     (const Foo__TestMess *message,
435
                      uint8_t       *out)
436
0
{
437
0
  assert(message->base.descriptor == &foo__test_mess__descriptor);
438
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
439
0
}
440
size_t foo__test_mess__pack_to_buffer
441
                     (const Foo__TestMess *message,
442
                      ProtobufCBuffer *buffer)
443
0
{
444
0
  assert(message->base.descriptor == &foo__test_mess__descriptor);
445
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
446
0
}
447
Foo__TestMess *
448
       foo__test_mess__unpack
449
                     (ProtobufCAllocator  *allocator,
450
                      size_t               len,
451
                      const uint8_t       *data)
452
0
{
453
0
  return (Foo__TestMess *)
454
0
     protobuf_c_message_unpack (&foo__test_mess__descriptor,
455
0
                                allocator, len, data);
456
0
}
457
void   foo__test_mess__free_unpacked
458
                     (Foo__TestMess *message,
459
                      ProtobufCAllocator *allocator)
460
0
{
461
0
  if(!message)
462
0
    return;
463
0
  assert(message->base.descriptor == &foo__test_mess__descriptor);
464
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
465
0
}
466
void   foo__test_mess_packed__init
467
                     (Foo__TestMessPacked         *message)
468
0
{
469
0
  static const Foo__TestMessPacked init_value = FOO__TEST_MESS_PACKED__INIT;
470
0
  *message = init_value;
471
0
}
472
size_t foo__test_mess_packed__get_packed_size
473
                     (const Foo__TestMessPacked *message)
474
0
{
475
0
  assert(message->base.descriptor == &foo__test_mess_packed__descriptor);
476
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
477
0
}
478
size_t foo__test_mess_packed__pack
479
                     (const Foo__TestMessPacked *message,
480
                      uint8_t       *out)
481
0
{
482
0
  assert(message->base.descriptor == &foo__test_mess_packed__descriptor);
483
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
484
0
}
485
size_t foo__test_mess_packed__pack_to_buffer
486
                     (const Foo__TestMessPacked *message,
487
                      ProtobufCBuffer *buffer)
488
0
{
489
0
  assert(message->base.descriptor == &foo__test_mess_packed__descriptor);
490
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
491
0
}
492
Foo__TestMessPacked *
493
       foo__test_mess_packed__unpack
494
                     (ProtobufCAllocator  *allocator,
495
                      size_t               len,
496
                      const uint8_t       *data)
497
0
{
498
0
  return (Foo__TestMessPacked *)
499
0
     protobuf_c_message_unpack (&foo__test_mess_packed__descriptor,
500
0
                                allocator, len, data);
501
0
}
502
void   foo__test_mess_packed__free_unpacked
503
                     (Foo__TestMessPacked *message,
504
                      ProtobufCAllocator *allocator)
505
0
{
506
0
  if(!message)
507
0
    return;
508
0
  assert(message->base.descriptor == &foo__test_mess_packed__descriptor);
509
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
510
0
}
511
void   foo__test_mess_oneof__init
512
                     (Foo__TestMessOneof         *message)
513
8.80k
{
514
8.80k
  static const Foo__TestMessOneof init_value = FOO__TEST_MESS_ONEOF__INIT;
515
8.80k
  *message = init_value;
516
8.80k
}
517
size_t foo__test_mess_oneof__get_packed_size
518
                     (const Foo__TestMessOneof *message)
519
0
{
520
0
  assert(message->base.descriptor == &foo__test_mess_oneof__descriptor);
521
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
522
0
}
523
size_t foo__test_mess_oneof__pack
524
                     (const Foo__TestMessOneof *message,
525
                      uint8_t       *out)
526
0
{
527
0
  assert(message->base.descriptor == &foo__test_mess_oneof__descriptor);
528
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
529
0
}
530
size_t foo__test_mess_oneof__pack_to_buffer
531
                     (const Foo__TestMessOneof *message,
532
                      ProtobufCBuffer *buffer)
533
0
{
534
0
  assert(message->base.descriptor == &foo__test_mess_oneof__descriptor);
535
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
536
0
}
537
Foo__TestMessOneof *
538
       foo__test_mess_oneof__unpack
539
                     (ProtobufCAllocator  *allocator,
540
                      size_t               len,
541
                      const uint8_t       *data)
542
0
{
543
0
  return (Foo__TestMessOneof *)
544
0
     protobuf_c_message_unpack (&foo__test_mess_oneof__descriptor,
545
0
                                allocator, len, data);
546
0
}
547
void   foo__test_mess_oneof__free_unpacked
548
                     (Foo__TestMessOneof *message,
549
                      ProtobufCAllocator *allocator)
550
0
{
551
0
  if(!message)
552
0
    return;
553
0
  assert(message->base.descriptor == &foo__test_mess_oneof__descriptor);
554
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
555
0
}
556
void   foo__test_mess_required_int32__init
557
                     (Foo__TestMessRequiredInt32         *message)
558
0
{
559
0
  static const Foo__TestMessRequiredInt32 init_value = FOO__TEST_MESS_REQUIRED_INT32__INIT;
560
0
  *message = init_value;
561
0
}
562
size_t foo__test_mess_required_int32__get_packed_size
563
                     (const Foo__TestMessRequiredInt32 *message)
564
0
{
565
0
  assert(message->base.descriptor == &foo__test_mess_required_int32__descriptor);
566
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
567
0
}
568
size_t foo__test_mess_required_int32__pack
569
                     (const Foo__TestMessRequiredInt32 *message,
570
                      uint8_t       *out)
571
0
{
572
0
  assert(message->base.descriptor == &foo__test_mess_required_int32__descriptor);
573
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
574
0
}
575
size_t foo__test_mess_required_int32__pack_to_buffer
576
                     (const Foo__TestMessRequiredInt32 *message,
577
                      ProtobufCBuffer *buffer)
578
0
{
579
0
  assert(message->base.descriptor == &foo__test_mess_required_int32__descriptor);
580
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
581
0
}
582
Foo__TestMessRequiredInt32 *
583
       foo__test_mess_required_int32__unpack
584
                     (ProtobufCAllocator  *allocator,
585
                      size_t               len,
586
                      const uint8_t       *data)
587
0
{
588
0
  return (Foo__TestMessRequiredInt32 *)
589
0
     protobuf_c_message_unpack (&foo__test_mess_required_int32__descriptor,
590
0
                                allocator, len, data);
591
0
}
592
void   foo__test_mess_required_int32__free_unpacked
593
                     (Foo__TestMessRequiredInt32 *message,
594
                      ProtobufCAllocator *allocator)
595
0
{
596
0
  if(!message)
597
0
    return;
598
0
  assert(message->base.descriptor == &foo__test_mess_required_int32__descriptor);
599
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
600
0
}
601
void   foo__test_mess_required_sint32__init
602
                     (Foo__TestMessRequiredSInt32         *message)
603
0
{
604
0
  static const Foo__TestMessRequiredSInt32 init_value = FOO__TEST_MESS_REQUIRED_SINT32__INIT;
605
0
  *message = init_value;
606
0
}
607
size_t foo__test_mess_required_sint32__get_packed_size
608
                     (const Foo__TestMessRequiredSInt32 *message)
609
0
{
610
0
  assert(message->base.descriptor == &foo__test_mess_required_sint32__descriptor);
611
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
612
0
}
613
size_t foo__test_mess_required_sint32__pack
614
                     (const Foo__TestMessRequiredSInt32 *message,
615
                      uint8_t       *out)
616
0
{
617
0
  assert(message->base.descriptor == &foo__test_mess_required_sint32__descriptor);
618
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
619
0
}
620
size_t foo__test_mess_required_sint32__pack_to_buffer
621
                     (const Foo__TestMessRequiredSInt32 *message,
622
                      ProtobufCBuffer *buffer)
623
0
{
624
0
  assert(message->base.descriptor == &foo__test_mess_required_sint32__descriptor);
625
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
626
0
}
627
Foo__TestMessRequiredSInt32 *
628
       foo__test_mess_required_sint32__unpack
629
                     (ProtobufCAllocator  *allocator,
630
                      size_t               len,
631
                      const uint8_t       *data)
632
0
{
633
0
  return (Foo__TestMessRequiredSInt32 *)
634
0
     protobuf_c_message_unpack (&foo__test_mess_required_sint32__descriptor,
635
0
                                allocator, len, data);
636
0
}
637
void   foo__test_mess_required_sint32__free_unpacked
638
                     (Foo__TestMessRequiredSInt32 *message,
639
                      ProtobufCAllocator *allocator)
640
0
{
641
0
  if(!message)
642
0
    return;
643
0
  assert(message->base.descriptor == &foo__test_mess_required_sint32__descriptor);
644
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
645
0
}
646
void   foo__test_mess_required_sfixed32__init
647
                     (Foo__TestMessRequiredSFixed32         *message)
648
0
{
649
0
  static const Foo__TestMessRequiredSFixed32 init_value = FOO__TEST_MESS_REQUIRED_SFIXED32__INIT;
650
0
  *message = init_value;
651
0
}
652
size_t foo__test_mess_required_sfixed32__get_packed_size
653
                     (const Foo__TestMessRequiredSFixed32 *message)
654
0
{
655
0
  assert(message->base.descriptor == &foo__test_mess_required_sfixed32__descriptor);
656
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
657
0
}
658
size_t foo__test_mess_required_sfixed32__pack
659
                     (const Foo__TestMessRequiredSFixed32 *message,
660
                      uint8_t       *out)
661
0
{
662
0
  assert(message->base.descriptor == &foo__test_mess_required_sfixed32__descriptor);
663
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
664
0
}
665
size_t foo__test_mess_required_sfixed32__pack_to_buffer
666
                     (const Foo__TestMessRequiredSFixed32 *message,
667
                      ProtobufCBuffer *buffer)
668
0
{
669
0
  assert(message->base.descriptor == &foo__test_mess_required_sfixed32__descriptor);
670
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
671
0
}
672
Foo__TestMessRequiredSFixed32 *
673
       foo__test_mess_required_sfixed32__unpack
674
                     (ProtobufCAllocator  *allocator,
675
                      size_t               len,
676
                      const uint8_t       *data)
677
0
{
678
0
  return (Foo__TestMessRequiredSFixed32 *)
679
0
     protobuf_c_message_unpack (&foo__test_mess_required_sfixed32__descriptor,
680
0
                                allocator, len, data);
681
0
}
682
void   foo__test_mess_required_sfixed32__free_unpacked
683
                     (Foo__TestMessRequiredSFixed32 *message,
684
                      ProtobufCAllocator *allocator)
685
0
{
686
0
  if(!message)
687
0
    return;
688
0
  assert(message->base.descriptor == &foo__test_mess_required_sfixed32__descriptor);
689
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
690
0
}
691
void   foo__test_mess_required_int64__init
692
                     (Foo__TestMessRequiredInt64         *message)
693
0
{
694
0
  static const Foo__TestMessRequiredInt64 init_value = FOO__TEST_MESS_REQUIRED_INT64__INIT;
695
0
  *message = init_value;
696
0
}
697
size_t foo__test_mess_required_int64__get_packed_size
698
                     (const Foo__TestMessRequiredInt64 *message)
699
0
{
700
0
  assert(message->base.descriptor == &foo__test_mess_required_int64__descriptor);
701
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
702
0
}
703
size_t foo__test_mess_required_int64__pack
704
                     (const Foo__TestMessRequiredInt64 *message,
705
                      uint8_t       *out)
706
0
{
707
0
  assert(message->base.descriptor == &foo__test_mess_required_int64__descriptor);
708
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
709
0
}
710
size_t foo__test_mess_required_int64__pack_to_buffer
711
                     (const Foo__TestMessRequiredInt64 *message,
712
                      ProtobufCBuffer *buffer)
713
0
{
714
0
  assert(message->base.descriptor == &foo__test_mess_required_int64__descriptor);
715
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
716
0
}
717
Foo__TestMessRequiredInt64 *
718
       foo__test_mess_required_int64__unpack
719
                     (ProtobufCAllocator  *allocator,
720
                      size_t               len,
721
                      const uint8_t       *data)
722
0
{
723
0
  return (Foo__TestMessRequiredInt64 *)
724
0
     protobuf_c_message_unpack (&foo__test_mess_required_int64__descriptor,
725
0
                                allocator, len, data);
726
0
}
727
void   foo__test_mess_required_int64__free_unpacked
728
                     (Foo__TestMessRequiredInt64 *message,
729
                      ProtobufCAllocator *allocator)
730
0
{
731
0
  if(!message)
732
0
    return;
733
0
  assert(message->base.descriptor == &foo__test_mess_required_int64__descriptor);
734
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
735
0
}
736
void   foo__test_mess_required_sint64__init
737
                     (Foo__TestMessRequiredSInt64         *message)
738
0
{
739
0
  static const Foo__TestMessRequiredSInt64 init_value = FOO__TEST_MESS_REQUIRED_SINT64__INIT;
740
0
  *message = init_value;
741
0
}
742
size_t foo__test_mess_required_sint64__get_packed_size
743
                     (const Foo__TestMessRequiredSInt64 *message)
744
0
{
745
0
  assert(message->base.descriptor == &foo__test_mess_required_sint64__descriptor);
746
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
747
0
}
748
size_t foo__test_mess_required_sint64__pack
749
                     (const Foo__TestMessRequiredSInt64 *message,
750
                      uint8_t       *out)
751
0
{
752
0
  assert(message->base.descriptor == &foo__test_mess_required_sint64__descriptor);
753
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
754
0
}
755
size_t foo__test_mess_required_sint64__pack_to_buffer
756
                     (const Foo__TestMessRequiredSInt64 *message,
757
                      ProtobufCBuffer *buffer)
758
0
{
759
0
  assert(message->base.descriptor == &foo__test_mess_required_sint64__descriptor);
760
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
761
0
}
762
Foo__TestMessRequiredSInt64 *
763
       foo__test_mess_required_sint64__unpack
764
                     (ProtobufCAllocator  *allocator,
765
                      size_t               len,
766
                      const uint8_t       *data)
767
0
{
768
0
  return (Foo__TestMessRequiredSInt64 *)
769
0
     protobuf_c_message_unpack (&foo__test_mess_required_sint64__descriptor,
770
0
                                allocator, len, data);
771
0
}
772
void   foo__test_mess_required_sint64__free_unpacked
773
                     (Foo__TestMessRequiredSInt64 *message,
774
                      ProtobufCAllocator *allocator)
775
0
{
776
0
  if(!message)
777
0
    return;
778
0
  assert(message->base.descriptor == &foo__test_mess_required_sint64__descriptor);
779
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
780
0
}
781
void   foo__test_mess_required_sfixed64__init
782
                     (Foo__TestMessRequiredSFixed64         *message)
783
0
{
784
0
  static const Foo__TestMessRequiredSFixed64 init_value = FOO__TEST_MESS_REQUIRED_SFIXED64__INIT;
785
0
  *message = init_value;
786
0
}
787
size_t foo__test_mess_required_sfixed64__get_packed_size
788
                     (const Foo__TestMessRequiredSFixed64 *message)
789
0
{
790
0
  assert(message->base.descriptor == &foo__test_mess_required_sfixed64__descriptor);
791
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
792
0
}
793
size_t foo__test_mess_required_sfixed64__pack
794
                     (const Foo__TestMessRequiredSFixed64 *message,
795
                      uint8_t       *out)
796
0
{
797
0
  assert(message->base.descriptor == &foo__test_mess_required_sfixed64__descriptor);
798
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
799
0
}
800
size_t foo__test_mess_required_sfixed64__pack_to_buffer
801
                     (const Foo__TestMessRequiredSFixed64 *message,
802
                      ProtobufCBuffer *buffer)
803
0
{
804
0
  assert(message->base.descriptor == &foo__test_mess_required_sfixed64__descriptor);
805
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
806
0
}
807
Foo__TestMessRequiredSFixed64 *
808
       foo__test_mess_required_sfixed64__unpack
809
                     (ProtobufCAllocator  *allocator,
810
                      size_t               len,
811
                      const uint8_t       *data)
812
0
{
813
0
  return (Foo__TestMessRequiredSFixed64 *)
814
0
     protobuf_c_message_unpack (&foo__test_mess_required_sfixed64__descriptor,
815
0
                                allocator, len, data);
816
0
}
817
void   foo__test_mess_required_sfixed64__free_unpacked
818
                     (Foo__TestMessRequiredSFixed64 *message,
819
                      ProtobufCAllocator *allocator)
820
0
{
821
0
  if(!message)
822
0
    return;
823
0
  assert(message->base.descriptor == &foo__test_mess_required_sfixed64__descriptor);
824
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
825
0
}
826
void   foo__test_mess_required_uint32__init
827
                     (Foo__TestMessRequiredUInt32         *message)
828
0
{
829
0
  static const Foo__TestMessRequiredUInt32 init_value = FOO__TEST_MESS_REQUIRED_UINT32__INIT;
830
0
  *message = init_value;
831
0
}
832
size_t foo__test_mess_required_uint32__get_packed_size
833
                     (const Foo__TestMessRequiredUInt32 *message)
834
0
{
835
0
  assert(message->base.descriptor == &foo__test_mess_required_uint32__descriptor);
836
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
837
0
}
838
size_t foo__test_mess_required_uint32__pack
839
                     (const Foo__TestMessRequiredUInt32 *message,
840
                      uint8_t       *out)
841
0
{
842
0
  assert(message->base.descriptor == &foo__test_mess_required_uint32__descriptor);
843
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
844
0
}
845
size_t foo__test_mess_required_uint32__pack_to_buffer
846
                     (const Foo__TestMessRequiredUInt32 *message,
847
                      ProtobufCBuffer *buffer)
848
0
{
849
0
  assert(message->base.descriptor == &foo__test_mess_required_uint32__descriptor);
850
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
851
0
}
852
Foo__TestMessRequiredUInt32 *
853
       foo__test_mess_required_uint32__unpack
854
                     (ProtobufCAllocator  *allocator,
855
                      size_t               len,
856
                      const uint8_t       *data)
857
0
{
858
0
  return (Foo__TestMessRequiredUInt32 *)
859
0
     protobuf_c_message_unpack (&foo__test_mess_required_uint32__descriptor,
860
0
                                allocator, len, data);
861
0
}
862
void   foo__test_mess_required_uint32__free_unpacked
863
                     (Foo__TestMessRequiredUInt32 *message,
864
                      ProtobufCAllocator *allocator)
865
0
{
866
0
  if(!message)
867
0
    return;
868
0
  assert(message->base.descriptor == &foo__test_mess_required_uint32__descriptor);
869
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
870
0
}
871
void   foo__test_mess_required_fixed32__init
872
                     (Foo__TestMessRequiredFixed32         *message)
873
0
{
874
0
  static const Foo__TestMessRequiredFixed32 init_value = FOO__TEST_MESS_REQUIRED_FIXED32__INIT;
875
0
  *message = init_value;
876
0
}
877
size_t foo__test_mess_required_fixed32__get_packed_size
878
                     (const Foo__TestMessRequiredFixed32 *message)
879
0
{
880
0
  assert(message->base.descriptor == &foo__test_mess_required_fixed32__descriptor);
881
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
882
0
}
883
size_t foo__test_mess_required_fixed32__pack
884
                     (const Foo__TestMessRequiredFixed32 *message,
885
                      uint8_t       *out)
886
0
{
887
0
  assert(message->base.descriptor == &foo__test_mess_required_fixed32__descriptor);
888
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
889
0
}
890
size_t foo__test_mess_required_fixed32__pack_to_buffer
891
                     (const Foo__TestMessRequiredFixed32 *message,
892
                      ProtobufCBuffer *buffer)
893
0
{
894
0
  assert(message->base.descriptor == &foo__test_mess_required_fixed32__descriptor);
895
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
896
0
}
897
Foo__TestMessRequiredFixed32 *
898
       foo__test_mess_required_fixed32__unpack
899
                     (ProtobufCAllocator  *allocator,
900
                      size_t               len,
901
                      const uint8_t       *data)
902
0
{
903
0
  return (Foo__TestMessRequiredFixed32 *)
904
0
     protobuf_c_message_unpack (&foo__test_mess_required_fixed32__descriptor,
905
0
                                allocator, len, data);
906
0
}
907
void   foo__test_mess_required_fixed32__free_unpacked
908
                     (Foo__TestMessRequiredFixed32 *message,
909
                      ProtobufCAllocator *allocator)
910
0
{
911
0
  if(!message)
912
0
    return;
913
0
  assert(message->base.descriptor == &foo__test_mess_required_fixed32__descriptor);
914
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
915
0
}
916
void   foo__test_mess_required_uint64__init
917
                     (Foo__TestMessRequiredUInt64         *message)
918
0
{
919
0
  static const Foo__TestMessRequiredUInt64 init_value = FOO__TEST_MESS_REQUIRED_UINT64__INIT;
920
0
  *message = init_value;
921
0
}
922
size_t foo__test_mess_required_uint64__get_packed_size
923
                     (const Foo__TestMessRequiredUInt64 *message)
924
0
{
925
0
  assert(message->base.descriptor == &foo__test_mess_required_uint64__descriptor);
926
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
927
0
}
928
size_t foo__test_mess_required_uint64__pack
929
                     (const Foo__TestMessRequiredUInt64 *message,
930
                      uint8_t       *out)
931
0
{
932
0
  assert(message->base.descriptor == &foo__test_mess_required_uint64__descriptor);
933
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
934
0
}
935
size_t foo__test_mess_required_uint64__pack_to_buffer
936
                     (const Foo__TestMessRequiredUInt64 *message,
937
                      ProtobufCBuffer *buffer)
938
0
{
939
0
  assert(message->base.descriptor == &foo__test_mess_required_uint64__descriptor);
940
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
941
0
}
942
Foo__TestMessRequiredUInt64 *
943
       foo__test_mess_required_uint64__unpack
944
                     (ProtobufCAllocator  *allocator,
945
                      size_t               len,
946
                      const uint8_t       *data)
947
0
{
948
0
  return (Foo__TestMessRequiredUInt64 *)
949
0
     protobuf_c_message_unpack (&foo__test_mess_required_uint64__descriptor,
950
0
                                allocator, len, data);
951
0
}
952
void   foo__test_mess_required_uint64__free_unpacked
953
                     (Foo__TestMessRequiredUInt64 *message,
954
                      ProtobufCAllocator *allocator)
955
0
{
956
0
  if(!message)
957
0
    return;
958
0
  assert(message->base.descriptor == &foo__test_mess_required_uint64__descriptor);
959
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
960
0
}
961
void   foo__test_mess_required_fixed64__init
962
                     (Foo__TestMessRequiredFixed64         *message)
963
0
{
964
0
  static const Foo__TestMessRequiredFixed64 init_value = FOO__TEST_MESS_REQUIRED_FIXED64__INIT;
965
0
  *message = init_value;
966
0
}
967
size_t foo__test_mess_required_fixed64__get_packed_size
968
                     (const Foo__TestMessRequiredFixed64 *message)
969
0
{
970
0
  assert(message->base.descriptor == &foo__test_mess_required_fixed64__descriptor);
971
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
972
0
}
973
size_t foo__test_mess_required_fixed64__pack
974
                     (const Foo__TestMessRequiredFixed64 *message,
975
                      uint8_t       *out)
976
0
{
977
0
  assert(message->base.descriptor == &foo__test_mess_required_fixed64__descriptor);
978
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
979
0
}
980
size_t foo__test_mess_required_fixed64__pack_to_buffer
981
                     (const Foo__TestMessRequiredFixed64 *message,
982
                      ProtobufCBuffer *buffer)
983
0
{
984
0
  assert(message->base.descriptor == &foo__test_mess_required_fixed64__descriptor);
985
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
986
0
}
987
Foo__TestMessRequiredFixed64 *
988
       foo__test_mess_required_fixed64__unpack
989
                     (ProtobufCAllocator  *allocator,
990
                      size_t               len,
991
                      const uint8_t       *data)
992
0
{
993
0
  return (Foo__TestMessRequiredFixed64 *)
994
0
     protobuf_c_message_unpack (&foo__test_mess_required_fixed64__descriptor,
995
0
                                allocator, len, data);
996
0
}
997
void   foo__test_mess_required_fixed64__free_unpacked
998
                     (Foo__TestMessRequiredFixed64 *message,
999
                      ProtobufCAllocator *allocator)
1000
0
{
1001
0
  if(!message)
1002
0
    return;
1003
0
  assert(message->base.descriptor == &foo__test_mess_required_fixed64__descriptor);
1004
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1005
0
}
1006
void   foo__test_mess_required_float__init
1007
                     (Foo__TestMessRequiredFloat         *message)
1008
0
{
1009
0
  static const Foo__TestMessRequiredFloat init_value = FOO__TEST_MESS_REQUIRED_FLOAT__INIT;
1010
0
  *message = init_value;
1011
0
}
1012
size_t foo__test_mess_required_float__get_packed_size
1013
                     (const Foo__TestMessRequiredFloat *message)
1014
0
{
1015
0
  assert(message->base.descriptor == &foo__test_mess_required_float__descriptor);
1016
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1017
0
}
1018
size_t foo__test_mess_required_float__pack
1019
                     (const Foo__TestMessRequiredFloat *message,
1020
                      uint8_t       *out)
1021
0
{
1022
0
  assert(message->base.descriptor == &foo__test_mess_required_float__descriptor);
1023
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1024
0
}
1025
size_t foo__test_mess_required_float__pack_to_buffer
1026
                     (const Foo__TestMessRequiredFloat *message,
1027
                      ProtobufCBuffer *buffer)
1028
0
{
1029
0
  assert(message->base.descriptor == &foo__test_mess_required_float__descriptor);
1030
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1031
0
}
1032
Foo__TestMessRequiredFloat *
1033
       foo__test_mess_required_float__unpack
1034
                     (ProtobufCAllocator  *allocator,
1035
                      size_t               len,
1036
                      const uint8_t       *data)
1037
0
{
1038
0
  return (Foo__TestMessRequiredFloat *)
1039
0
     protobuf_c_message_unpack (&foo__test_mess_required_float__descriptor,
1040
0
                                allocator, len, data);
1041
0
}
1042
void   foo__test_mess_required_float__free_unpacked
1043
                     (Foo__TestMessRequiredFloat *message,
1044
                      ProtobufCAllocator *allocator)
1045
0
{
1046
0
  if(!message)
1047
0
    return;
1048
0
  assert(message->base.descriptor == &foo__test_mess_required_float__descriptor);
1049
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1050
0
}
1051
void   foo__test_mess_required_double__init
1052
                     (Foo__TestMessRequiredDouble         *message)
1053
0
{
1054
0
  static const Foo__TestMessRequiredDouble init_value = FOO__TEST_MESS_REQUIRED_DOUBLE__INIT;
1055
0
  *message = init_value;
1056
0
}
1057
size_t foo__test_mess_required_double__get_packed_size
1058
                     (const Foo__TestMessRequiredDouble *message)
1059
0
{
1060
0
  assert(message->base.descriptor == &foo__test_mess_required_double__descriptor);
1061
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1062
0
}
1063
size_t foo__test_mess_required_double__pack
1064
                     (const Foo__TestMessRequiredDouble *message,
1065
                      uint8_t       *out)
1066
0
{
1067
0
  assert(message->base.descriptor == &foo__test_mess_required_double__descriptor);
1068
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1069
0
}
1070
size_t foo__test_mess_required_double__pack_to_buffer
1071
                     (const Foo__TestMessRequiredDouble *message,
1072
                      ProtobufCBuffer *buffer)
1073
0
{
1074
0
  assert(message->base.descriptor == &foo__test_mess_required_double__descriptor);
1075
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1076
0
}
1077
Foo__TestMessRequiredDouble *
1078
       foo__test_mess_required_double__unpack
1079
                     (ProtobufCAllocator  *allocator,
1080
                      size_t               len,
1081
                      const uint8_t       *data)
1082
0
{
1083
0
  return (Foo__TestMessRequiredDouble *)
1084
0
     protobuf_c_message_unpack (&foo__test_mess_required_double__descriptor,
1085
0
                                allocator, len, data);
1086
0
}
1087
void   foo__test_mess_required_double__free_unpacked
1088
                     (Foo__TestMessRequiredDouble *message,
1089
                      ProtobufCAllocator *allocator)
1090
0
{
1091
0
  if(!message)
1092
0
    return;
1093
0
  assert(message->base.descriptor == &foo__test_mess_required_double__descriptor);
1094
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1095
0
}
1096
void   foo__test_mess_required_bool__init
1097
                     (Foo__TestMessRequiredBool         *message)
1098
0
{
1099
0
  static const Foo__TestMessRequiredBool init_value = FOO__TEST_MESS_REQUIRED_BOOL__INIT;
1100
0
  *message = init_value;
1101
0
}
1102
size_t foo__test_mess_required_bool__get_packed_size
1103
                     (const Foo__TestMessRequiredBool *message)
1104
0
{
1105
0
  assert(message->base.descriptor == &foo__test_mess_required_bool__descriptor);
1106
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1107
0
}
1108
size_t foo__test_mess_required_bool__pack
1109
                     (const Foo__TestMessRequiredBool *message,
1110
                      uint8_t       *out)
1111
0
{
1112
0
  assert(message->base.descriptor == &foo__test_mess_required_bool__descriptor);
1113
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1114
0
}
1115
size_t foo__test_mess_required_bool__pack_to_buffer
1116
                     (const Foo__TestMessRequiredBool *message,
1117
                      ProtobufCBuffer *buffer)
1118
0
{
1119
0
  assert(message->base.descriptor == &foo__test_mess_required_bool__descriptor);
1120
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1121
0
}
1122
Foo__TestMessRequiredBool *
1123
       foo__test_mess_required_bool__unpack
1124
                     (ProtobufCAllocator  *allocator,
1125
                      size_t               len,
1126
                      const uint8_t       *data)
1127
0
{
1128
0
  return (Foo__TestMessRequiredBool *)
1129
0
     protobuf_c_message_unpack (&foo__test_mess_required_bool__descriptor,
1130
0
                                allocator, len, data);
1131
0
}
1132
void   foo__test_mess_required_bool__free_unpacked
1133
                     (Foo__TestMessRequiredBool *message,
1134
                      ProtobufCAllocator *allocator)
1135
0
{
1136
0
  if(!message)
1137
0
    return;
1138
0
  assert(message->base.descriptor == &foo__test_mess_required_bool__descriptor);
1139
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1140
0
}
1141
void   foo__test_mess_required_enum__init
1142
                     (Foo__TestMessRequiredEnum         *message)
1143
0
{
1144
0
  static const Foo__TestMessRequiredEnum init_value = FOO__TEST_MESS_REQUIRED_ENUM__INIT;
1145
0
  *message = init_value;
1146
0
}
1147
size_t foo__test_mess_required_enum__get_packed_size
1148
                     (const Foo__TestMessRequiredEnum *message)
1149
0
{
1150
0
  assert(message->base.descriptor == &foo__test_mess_required_enum__descriptor);
1151
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1152
0
}
1153
size_t foo__test_mess_required_enum__pack
1154
                     (const Foo__TestMessRequiredEnum *message,
1155
                      uint8_t       *out)
1156
0
{
1157
0
  assert(message->base.descriptor == &foo__test_mess_required_enum__descriptor);
1158
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1159
0
}
1160
size_t foo__test_mess_required_enum__pack_to_buffer
1161
                     (const Foo__TestMessRequiredEnum *message,
1162
                      ProtobufCBuffer *buffer)
1163
0
{
1164
0
  assert(message->base.descriptor == &foo__test_mess_required_enum__descriptor);
1165
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1166
0
}
1167
Foo__TestMessRequiredEnum *
1168
       foo__test_mess_required_enum__unpack
1169
                     (ProtobufCAllocator  *allocator,
1170
                      size_t               len,
1171
                      const uint8_t       *data)
1172
0
{
1173
0
  return (Foo__TestMessRequiredEnum *)
1174
0
     protobuf_c_message_unpack (&foo__test_mess_required_enum__descriptor,
1175
0
                                allocator, len, data);
1176
0
}
1177
void   foo__test_mess_required_enum__free_unpacked
1178
                     (Foo__TestMessRequiredEnum *message,
1179
                      ProtobufCAllocator *allocator)
1180
0
{
1181
0
  if(!message)
1182
0
    return;
1183
0
  assert(message->base.descriptor == &foo__test_mess_required_enum__descriptor);
1184
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1185
0
}
1186
void   foo__test_mess_required_enum_small__init
1187
                     (Foo__TestMessRequiredEnumSmall         *message)
1188
0
{
1189
0
  static const Foo__TestMessRequiredEnumSmall init_value = FOO__TEST_MESS_REQUIRED_ENUM_SMALL__INIT;
1190
0
  *message = init_value;
1191
0
}
1192
size_t foo__test_mess_required_enum_small__get_packed_size
1193
                     (const Foo__TestMessRequiredEnumSmall *message)
1194
0
{
1195
0
  assert(message->base.descriptor == &foo__test_mess_required_enum_small__descriptor);
1196
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1197
0
}
1198
size_t foo__test_mess_required_enum_small__pack
1199
                     (const Foo__TestMessRequiredEnumSmall *message,
1200
                      uint8_t       *out)
1201
0
{
1202
0
  assert(message->base.descriptor == &foo__test_mess_required_enum_small__descriptor);
1203
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1204
0
}
1205
size_t foo__test_mess_required_enum_small__pack_to_buffer
1206
                     (const Foo__TestMessRequiredEnumSmall *message,
1207
                      ProtobufCBuffer *buffer)
1208
0
{
1209
0
  assert(message->base.descriptor == &foo__test_mess_required_enum_small__descriptor);
1210
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1211
0
}
1212
Foo__TestMessRequiredEnumSmall *
1213
       foo__test_mess_required_enum_small__unpack
1214
                     (ProtobufCAllocator  *allocator,
1215
                      size_t               len,
1216
                      const uint8_t       *data)
1217
0
{
1218
0
  return (Foo__TestMessRequiredEnumSmall *)
1219
0
     protobuf_c_message_unpack (&foo__test_mess_required_enum_small__descriptor,
1220
0
                                allocator, len, data);
1221
0
}
1222
void   foo__test_mess_required_enum_small__free_unpacked
1223
                     (Foo__TestMessRequiredEnumSmall *message,
1224
                      ProtobufCAllocator *allocator)
1225
0
{
1226
0
  if(!message)
1227
0
    return;
1228
0
  assert(message->base.descriptor == &foo__test_mess_required_enum_small__descriptor);
1229
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1230
0
}
1231
void   foo__test_mess_required_string__init
1232
                     (Foo__TestMessRequiredString         *message)
1233
0
{
1234
0
  static const Foo__TestMessRequiredString init_value = FOO__TEST_MESS_REQUIRED_STRING__INIT;
1235
0
  *message = init_value;
1236
0
}
1237
size_t foo__test_mess_required_string__get_packed_size
1238
                     (const Foo__TestMessRequiredString *message)
1239
0
{
1240
0
  assert(message->base.descriptor == &foo__test_mess_required_string__descriptor);
1241
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1242
0
}
1243
size_t foo__test_mess_required_string__pack
1244
                     (const Foo__TestMessRequiredString *message,
1245
                      uint8_t       *out)
1246
0
{
1247
0
  assert(message->base.descriptor == &foo__test_mess_required_string__descriptor);
1248
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1249
0
}
1250
size_t foo__test_mess_required_string__pack_to_buffer
1251
                     (const Foo__TestMessRequiredString *message,
1252
                      ProtobufCBuffer *buffer)
1253
0
{
1254
0
  assert(message->base.descriptor == &foo__test_mess_required_string__descriptor);
1255
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1256
0
}
1257
Foo__TestMessRequiredString *
1258
       foo__test_mess_required_string__unpack
1259
                     (ProtobufCAllocator  *allocator,
1260
                      size_t               len,
1261
                      const uint8_t       *data)
1262
0
{
1263
0
  return (Foo__TestMessRequiredString *)
1264
0
     protobuf_c_message_unpack (&foo__test_mess_required_string__descriptor,
1265
0
                                allocator, len, data);
1266
0
}
1267
void   foo__test_mess_required_string__free_unpacked
1268
                     (Foo__TestMessRequiredString *message,
1269
                      ProtobufCAllocator *allocator)
1270
0
{
1271
0
  if(!message)
1272
0
    return;
1273
0
  assert(message->base.descriptor == &foo__test_mess_required_string__descriptor);
1274
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1275
0
}
1276
void   foo__test_mess_required_bytes__init
1277
                     (Foo__TestMessRequiredBytes         *message)
1278
0
{
1279
0
  static const Foo__TestMessRequiredBytes init_value = FOO__TEST_MESS_REQUIRED_BYTES__INIT;
1280
0
  *message = init_value;
1281
0
}
1282
size_t foo__test_mess_required_bytes__get_packed_size
1283
                     (const Foo__TestMessRequiredBytes *message)
1284
0
{
1285
0
  assert(message->base.descriptor == &foo__test_mess_required_bytes__descriptor);
1286
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1287
0
}
1288
size_t foo__test_mess_required_bytes__pack
1289
                     (const Foo__TestMessRequiredBytes *message,
1290
                      uint8_t       *out)
1291
0
{
1292
0
  assert(message->base.descriptor == &foo__test_mess_required_bytes__descriptor);
1293
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1294
0
}
1295
size_t foo__test_mess_required_bytes__pack_to_buffer
1296
                     (const Foo__TestMessRequiredBytes *message,
1297
                      ProtobufCBuffer *buffer)
1298
0
{
1299
0
  assert(message->base.descriptor == &foo__test_mess_required_bytes__descriptor);
1300
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1301
0
}
1302
Foo__TestMessRequiredBytes *
1303
       foo__test_mess_required_bytes__unpack
1304
                     (ProtobufCAllocator  *allocator,
1305
                      size_t               len,
1306
                      const uint8_t       *data)
1307
0
{
1308
0
  return (Foo__TestMessRequiredBytes *)
1309
0
     protobuf_c_message_unpack (&foo__test_mess_required_bytes__descriptor,
1310
0
                                allocator, len, data);
1311
0
}
1312
void   foo__test_mess_required_bytes__free_unpacked
1313
                     (Foo__TestMessRequiredBytes *message,
1314
                      ProtobufCAllocator *allocator)
1315
0
{
1316
0
  if(!message)
1317
0
    return;
1318
0
  assert(message->base.descriptor == &foo__test_mess_required_bytes__descriptor);
1319
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1320
0
}
1321
void   foo__test_mess_required_message__init
1322
                     (Foo__TestMessRequiredMessage         *message)
1323
0
{
1324
0
  static const Foo__TestMessRequiredMessage init_value = FOO__TEST_MESS_REQUIRED_MESSAGE__INIT;
1325
0
  *message = init_value;
1326
0
}
1327
size_t foo__test_mess_required_message__get_packed_size
1328
                     (const Foo__TestMessRequiredMessage *message)
1329
0
{
1330
0
  assert(message->base.descriptor == &foo__test_mess_required_message__descriptor);
1331
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1332
0
}
1333
size_t foo__test_mess_required_message__pack
1334
                     (const Foo__TestMessRequiredMessage *message,
1335
                      uint8_t       *out)
1336
0
{
1337
0
  assert(message->base.descriptor == &foo__test_mess_required_message__descriptor);
1338
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1339
0
}
1340
size_t foo__test_mess_required_message__pack_to_buffer
1341
                     (const Foo__TestMessRequiredMessage *message,
1342
                      ProtobufCBuffer *buffer)
1343
0
{
1344
0
  assert(message->base.descriptor == &foo__test_mess_required_message__descriptor);
1345
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1346
0
}
1347
Foo__TestMessRequiredMessage *
1348
       foo__test_mess_required_message__unpack
1349
                     (ProtobufCAllocator  *allocator,
1350
                      size_t               len,
1351
                      const uint8_t       *data)
1352
0
{
1353
0
  return (Foo__TestMessRequiredMessage *)
1354
0
     protobuf_c_message_unpack (&foo__test_mess_required_message__descriptor,
1355
0
                                allocator, len, data);
1356
0
}
1357
void   foo__test_mess_required_message__free_unpacked
1358
                     (Foo__TestMessRequiredMessage *message,
1359
                      ProtobufCAllocator *allocator)
1360
0
{
1361
0
  if(!message)
1362
0
    return;
1363
0
  assert(message->base.descriptor == &foo__test_mess_required_message__descriptor);
1364
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1365
0
}
1366
void   foo__empty_mess__init
1367
                     (Foo__EmptyMess         *message)
1368
0
{
1369
0
  static const Foo__EmptyMess init_value = FOO__EMPTY_MESS__INIT;
1370
0
  *message = init_value;
1371
0
}
1372
size_t foo__empty_mess__get_packed_size
1373
                     (const Foo__EmptyMess *message)
1374
0
{
1375
0
  assert(message->base.descriptor == &foo__empty_mess__descriptor);
1376
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1377
0
}
1378
size_t foo__empty_mess__pack
1379
                     (const Foo__EmptyMess *message,
1380
                      uint8_t       *out)
1381
0
{
1382
0
  assert(message->base.descriptor == &foo__empty_mess__descriptor);
1383
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1384
0
}
1385
size_t foo__empty_mess__pack_to_buffer
1386
                     (const Foo__EmptyMess *message,
1387
                      ProtobufCBuffer *buffer)
1388
0
{
1389
0
  assert(message->base.descriptor == &foo__empty_mess__descriptor);
1390
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1391
0
}
1392
Foo__EmptyMess *
1393
       foo__empty_mess__unpack
1394
                     (ProtobufCAllocator  *allocator,
1395
                      size_t               len,
1396
                      const uint8_t       *data)
1397
0
{
1398
0
  return (Foo__EmptyMess *)
1399
0
     protobuf_c_message_unpack (&foo__empty_mess__descriptor,
1400
0
                                allocator, len, data);
1401
0
}
1402
void   foo__empty_mess__free_unpacked
1403
                     (Foo__EmptyMess *message,
1404
                      ProtobufCAllocator *allocator)
1405
0
{
1406
0
  if(!message)
1407
0
    return;
1408
0
  assert(message->base.descriptor == &foo__empty_mess__descriptor);
1409
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1410
0
}
1411
void   foo__default_required_values__init
1412
                     (Foo__DefaultRequiredValues         *message)
1413
0
{
1414
0
  static const Foo__DefaultRequiredValues init_value = FOO__DEFAULT_REQUIRED_VALUES__INIT;
1415
0
  *message = init_value;
1416
0
}
1417
size_t foo__default_required_values__get_packed_size
1418
                     (const Foo__DefaultRequiredValues *message)
1419
0
{
1420
0
  assert(message->base.descriptor == &foo__default_required_values__descriptor);
1421
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1422
0
}
1423
size_t foo__default_required_values__pack
1424
                     (const Foo__DefaultRequiredValues *message,
1425
                      uint8_t       *out)
1426
0
{
1427
0
  assert(message->base.descriptor == &foo__default_required_values__descriptor);
1428
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1429
0
}
1430
size_t foo__default_required_values__pack_to_buffer
1431
                     (const Foo__DefaultRequiredValues *message,
1432
                      ProtobufCBuffer *buffer)
1433
0
{
1434
0
  assert(message->base.descriptor == &foo__default_required_values__descriptor);
1435
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1436
0
}
1437
Foo__DefaultRequiredValues *
1438
       foo__default_required_values__unpack
1439
                     (ProtobufCAllocator  *allocator,
1440
                      size_t               len,
1441
                      const uint8_t       *data)
1442
0
{
1443
0
  return (Foo__DefaultRequiredValues *)
1444
0
     protobuf_c_message_unpack (&foo__default_required_values__descriptor,
1445
0
                                allocator, len, data);
1446
0
}
1447
void   foo__default_required_values__free_unpacked
1448
                     (Foo__DefaultRequiredValues *message,
1449
                      ProtobufCAllocator *allocator)
1450
0
{
1451
0
  if(!message)
1452
0
    return;
1453
0
  assert(message->base.descriptor == &foo__default_required_values__descriptor);
1454
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1455
0
}
1456
void   foo__default_optional_values__init
1457
                     (Foo__DefaultOptionalValues         *message)
1458
14.2k
{
1459
14.2k
  static const Foo__DefaultOptionalValues init_value = FOO__DEFAULT_OPTIONAL_VALUES__INIT;
1460
14.2k
  *message = init_value;
1461
14.2k
}
1462
size_t foo__default_optional_values__get_packed_size
1463
                     (const Foo__DefaultOptionalValues *message)
1464
0
{
1465
0
  assert(message->base.descriptor == &foo__default_optional_values__descriptor);
1466
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1467
0
}
1468
size_t foo__default_optional_values__pack
1469
                     (const Foo__DefaultOptionalValues *message,
1470
                      uint8_t       *out)
1471
0
{
1472
0
  assert(message->base.descriptor == &foo__default_optional_values__descriptor);
1473
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1474
0
}
1475
size_t foo__default_optional_values__pack_to_buffer
1476
                     (const Foo__DefaultOptionalValues *message,
1477
                      ProtobufCBuffer *buffer)
1478
0
{
1479
0
  assert(message->base.descriptor == &foo__default_optional_values__descriptor);
1480
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1481
0
}
1482
Foo__DefaultOptionalValues *
1483
       foo__default_optional_values__unpack
1484
                     (ProtobufCAllocator  *allocator,
1485
                      size_t               len,
1486
                      const uint8_t       *data)
1487
0
{
1488
0
  return (Foo__DefaultOptionalValues *)
1489
0
     protobuf_c_message_unpack (&foo__default_optional_values__descriptor,
1490
0
                                allocator, len, data);
1491
0
}
1492
void   foo__default_optional_values__free_unpacked
1493
                     (Foo__DefaultOptionalValues *message,
1494
                      ProtobufCAllocator *allocator)
1495
0
{
1496
0
  if(!message)
1497
0
    return;
1498
0
  assert(message->base.descriptor == &foo__default_optional_values__descriptor);
1499
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1500
0
}
1501
void   foo__lower_case__init
1502
                     (Foo__LowerCase         *message)
1503
0
{
1504
0
  static const Foo__LowerCase init_value = FOO__LOWER_CASE__INIT;
1505
0
  *message = init_value;
1506
0
}
1507
size_t foo__lower_case__get_packed_size
1508
                     (const Foo__LowerCase *message)
1509
0
{
1510
0
  assert(message->base.descriptor == &foo__lower_case__descriptor);
1511
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1512
0
}
1513
size_t foo__lower_case__pack
1514
                     (const Foo__LowerCase *message,
1515
                      uint8_t       *out)
1516
0
{
1517
0
  assert(message->base.descriptor == &foo__lower_case__descriptor);
1518
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1519
0
}
1520
size_t foo__lower_case__pack_to_buffer
1521
                     (const Foo__LowerCase *message,
1522
                      ProtobufCBuffer *buffer)
1523
0
{
1524
0
  assert(message->base.descriptor == &foo__lower_case__descriptor);
1525
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1526
0
}
1527
Foo__LowerCase *
1528
       foo__lower_case__unpack
1529
                     (ProtobufCAllocator  *allocator,
1530
                      size_t               len,
1531
                      const uint8_t       *data)
1532
0
{
1533
0
  return (Foo__LowerCase *)
1534
0
     protobuf_c_message_unpack (&foo__lower_case__descriptor,
1535
0
                                allocator, len, data);
1536
0
}
1537
void   foo__lower_case__free_unpacked
1538
                     (Foo__LowerCase *message,
1539
                      ProtobufCAllocator *allocator)
1540
0
{
1541
0
  if(!message)
1542
0
    return;
1543
0
  assert(message->base.descriptor == &foo__lower_case__descriptor);
1544
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1545
0
}
1546
void   foo__alloc_values__init
1547
                     (Foo__AllocValues         *message)
1548
0
{
1549
0
  static const Foo__AllocValues init_value = FOO__ALLOC_VALUES__INIT;
1550
0
  *message = init_value;
1551
0
}
1552
size_t foo__alloc_values__get_packed_size
1553
                     (const Foo__AllocValues *message)
1554
0
{
1555
0
  assert(message->base.descriptor == &foo__alloc_values__descriptor);
1556
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1557
0
}
1558
size_t foo__alloc_values__pack
1559
                     (const Foo__AllocValues *message,
1560
                      uint8_t       *out)
1561
0
{
1562
0
  assert(message->base.descriptor == &foo__alloc_values__descriptor);
1563
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1564
0
}
1565
size_t foo__alloc_values__pack_to_buffer
1566
                     (const Foo__AllocValues *message,
1567
                      ProtobufCBuffer *buffer)
1568
0
{
1569
0
  assert(message->base.descriptor == &foo__alloc_values__descriptor);
1570
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1571
0
}
1572
Foo__AllocValues *
1573
       foo__alloc_values__unpack
1574
                     (ProtobufCAllocator  *allocator,
1575
                      size_t               len,
1576
                      const uint8_t       *data)
1577
0
{
1578
0
  return (Foo__AllocValues *)
1579
0
     protobuf_c_message_unpack (&foo__alloc_values__descriptor,
1580
0
                                allocator, len, data);
1581
0
}
1582
void   foo__alloc_values__free_unpacked
1583
                     (Foo__AllocValues *message,
1584
                      ProtobufCAllocator *allocator)
1585
0
{
1586
0
  if(!message)
1587
0
    return;
1588
0
  assert(message->base.descriptor == &foo__alloc_values__descriptor);
1589
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1590
0
}
1591
void   foo__test_required_fields_bitmap__init
1592
                     (Foo__TestRequiredFieldsBitmap         *message)
1593
0
{
1594
0
  static const Foo__TestRequiredFieldsBitmap init_value = FOO__TEST_REQUIRED_FIELDS_BITMAP__INIT;
1595
0
  *message = init_value;
1596
0
}
1597
size_t foo__test_required_fields_bitmap__get_packed_size
1598
                     (const Foo__TestRequiredFieldsBitmap *message)
1599
0
{
1600
0
  assert(message->base.descriptor == &foo__test_required_fields_bitmap__descriptor);
1601
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1602
0
}
1603
size_t foo__test_required_fields_bitmap__pack
1604
                     (const Foo__TestRequiredFieldsBitmap *message,
1605
                      uint8_t       *out)
1606
0
{
1607
0
  assert(message->base.descriptor == &foo__test_required_fields_bitmap__descriptor);
1608
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1609
0
}
1610
size_t foo__test_required_fields_bitmap__pack_to_buffer
1611
                     (const Foo__TestRequiredFieldsBitmap *message,
1612
                      ProtobufCBuffer *buffer)
1613
0
{
1614
0
  assert(message->base.descriptor == &foo__test_required_fields_bitmap__descriptor);
1615
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1616
0
}
1617
Foo__TestRequiredFieldsBitmap *
1618
       foo__test_required_fields_bitmap__unpack
1619
                     (ProtobufCAllocator  *allocator,
1620
                      size_t               len,
1621
                      const uint8_t       *data)
1622
0
{
1623
0
  return (Foo__TestRequiredFieldsBitmap *)
1624
0
     protobuf_c_message_unpack (&foo__test_required_fields_bitmap__descriptor,
1625
0
                                allocator, len, data);
1626
0
}
1627
void   foo__test_required_fields_bitmap__free_unpacked
1628
                     (Foo__TestRequiredFieldsBitmap *message,
1629
                      ProtobufCAllocator *allocator)
1630
0
{
1631
0
  if(!message)
1632
0
    return;
1633
0
  assert(message->base.descriptor == &foo__test_required_fields_bitmap__descriptor);
1634
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1635
0
}
1636
void   foo__test_field_flags__init
1637
                     (Foo__TestFieldFlags         *message)
1638
6.76k
{
1639
6.76k
  static const Foo__TestFieldFlags init_value = FOO__TEST_FIELD_FLAGS__INIT;
1640
6.76k
  *message = init_value;
1641
6.76k
}
1642
size_t foo__test_field_flags__get_packed_size
1643
                     (const Foo__TestFieldFlags *message)
1644
1.03k
{
1645
1.03k
  assert(message->base.descriptor == &foo__test_field_flags__descriptor);
1646
1.03k
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1647
1.03k
}
1648
size_t foo__test_field_flags__pack
1649
                     (const Foo__TestFieldFlags *message,
1650
                      uint8_t       *out)
1651
1.03k
{
1652
1.03k
  assert(message->base.descriptor == &foo__test_field_flags__descriptor);
1653
1.03k
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1654
1.03k
}
1655
size_t foo__test_field_flags__pack_to_buffer
1656
                     (const Foo__TestFieldFlags *message,
1657
                      ProtobufCBuffer *buffer)
1658
0
{
1659
0
  assert(message->base.descriptor == &foo__test_field_flags__descriptor);
1660
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1661
0
}
1662
Foo__TestFieldFlags *
1663
       foo__test_field_flags__unpack
1664
                     (ProtobufCAllocator  *allocator,
1665
                      size_t               len,
1666
                      const uint8_t       *data)
1667
6.76k
{
1668
6.76k
  return (Foo__TestFieldFlags *)
1669
6.76k
     protobuf_c_message_unpack (&foo__test_field_flags__descriptor,
1670
6.76k
                                allocator, len, data);
1671
6.76k
}
1672
void   foo__test_field_flags__free_unpacked
1673
                     (Foo__TestFieldFlags *message,
1674
                      ProtobufCAllocator *allocator)
1675
6.76k
{
1676
6.76k
  if(!message)
1677
5.72k
    return;
1678
1.03k
  assert(message->base.descriptor == &foo__test_field_flags__descriptor);
1679
1.03k
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1680
1.03k
}
1681
void   foo__test_message_check__sub_message__init
1682
                     (Foo__TestMessageCheck__SubMessage         *message)
1683
7.65k
{
1684
7.65k
  static const Foo__TestMessageCheck__SubMessage init_value = FOO__TEST_MESSAGE_CHECK__SUB_MESSAGE__INIT;
1685
7.65k
  *message = init_value;
1686
7.65k
}
1687
void   foo__test_message_check__init
1688
                     (Foo__TestMessageCheck         *message)
1689
6.76k
{
1690
6.76k
  static const Foo__TestMessageCheck init_value = FOO__TEST_MESSAGE_CHECK__INIT;
1691
6.76k
  *message = init_value;
1692
6.76k
}
1693
size_t foo__test_message_check__get_packed_size
1694
                     (const Foo__TestMessageCheck *message)
1695
401
{
1696
401
  assert(message->base.descriptor == &foo__test_message_check__descriptor);
1697
401
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1698
401
}
1699
size_t foo__test_message_check__pack
1700
                     (const Foo__TestMessageCheck *message,
1701
                      uint8_t       *out)
1702
401
{
1703
401
  assert(message->base.descriptor == &foo__test_message_check__descriptor);
1704
401
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1705
401
}
1706
size_t foo__test_message_check__pack_to_buffer
1707
                     (const Foo__TestMessageCheck *message,
1708
                      ProtobufCBuffer *buffer)
1709
0
{
1710
0
  assert(message->base.descriptor == &foo__test_message_check__descriptor);
1711
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1712
0
}
1713
Foo__TestMessageCheck *
1714
       foo__test_message_check__unpack
1715
                     (ProtobufCAllocator  *allocator,
1716
                      size_t               len,
1717
                      const uint8_t       *data)
1718
6.76k
{
1719
6.76k
  return (Foo__TestMessageCheck *)
1720
6.76k
     protobuf_c_message_unpack (&foo__test_message_check__descriptor,
1721
6.76k
                                allocator, len, data);
1722
6.76k
}
1723
void   foo__test_message_check__free_unpacked
1724
                     (Foo__TestMessageCheck *message,
1725
                      ProtobufCAllocator *allocator)
1726
6.76k
{
1727
6.76k
  if(!message)
1728
6.35k
    return;
1729
401
  assert(message->base.descriptor == &foo__test_message_check__descriptor);
1730
401
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1731
401
}
1732
void   foo__test_mess_sub_mess__init
1733
                     (Foo__TestMessSubMess         *message)
1734
6.76k
{
1735
6.76k
  static const Foo__TestMessSubMess init_value = FOO__TEST_MESS_SUB_MESS__INIT;
1736
6.76k
  *message = init_value;
1737
6.76k
}
1738
size_t foo__test_mess_sub_mess__get_packed_size
1739
                     (const Foo__TestMessSubMess *message)
1740
3.57k
{
1741
3.57k
  assert(message->base.descriptor == &foo__test_mess_sub_mess__descriptor);
1742
3.57k
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1743
3.57k
}
1744
size_t foo__test_mess_sub_mess__pack
1745
                     (const Foo__TestMessSubMess *message,
1746
                      uint8_t       *out)
1747
3.57k
{
1748
3.57k
  assert(message->base.descriptor == &foo__test_mess_sub_mess__descriptor);
1749
3.57k
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1750
3.57k
}
1751
size_t foo__test_mess_sub_mess__pack_to_buffer
1752
                     (const Foo__TestMessSubMess *message,
1753
                      ProtobufCBuffer *buffer)
1754
0
{
1755
0
  assert(message->base.descriptor == &foo__test_mess_sub_mess__descriptor);
1756
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1757
0
}
1758
Foo__TestMessSubMess *
1759
       foo__test_mess_sub_mess__unpack
1760
                     (ProtobufCAllocator  *allocator,
1761
                      size_t               len,
1762
                      const uint8_t       *data)
1763
6.76k
{
1764
6.76k
  return (Foo__TestMessSubMess *)
1765
6.76k
     protobuf_c_message_unpack (&foo__test_mess_sub_mess__descriptor,
1766
6.76k
                                allocator, len, data);
1767
6.76k
}
1768
void   foo__test_mess_sub_mess__free_unpacked
1769
                     (Foo__TestMessSubMess *message,
1770
                      ProtobufCAllocator *allocator)
1771
6.76k
{
1772
6.76k
  if(!message)
1773
3.18k
    return;
1774
3.57k
  assert(message->base.descriptor == &foo__test_mess_sub_mess__descriptor);
1775
3.57k
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1776
3.57k
}
1777
uint8_t foo__sub_mess__sub_sub_mess__bytes1__default_value_data[] = "a \000 char";
1778
char foo__sub_mess__sub_sub_mess__str1__default_value[] = "hello world\n";
1779
uint8_t foo__sub_mess__sub_sub_mess__str2__default_value_data[] = "hello\000world\n";
1780
static const int32_t foo__sub_mess__sub_sub_mess__val1__default_value = 100;
1781
static const ProtobufCBinaryData foo__sub_mess__sub_sub_mess__bytes1__default_value = { 8, foo__sub_mess__sub_sub_mess__bytes1__default_value_data };
1782
static const ProtobufCBinaryData foo__sub_mess__sub_sub_mess__str2__default_value = { 12, foo__sub_mess__sub_sub_mess__str2__default_value_data };
1783
static const ProtobufCFieldDescriptor foo__sub_mess__sub_sub_mess__field_descriptors[5] =
1784
{
1785
  {
1786
    "val1",
1787
    1,
1788
    PROTOBUF_C_LABEL_OPTIONAL,
1789
    PROTOBUF_C_TYPE_INT32,
1790
    offsetof(Foo__SubMess__SubSubMess, has_val1),
1791
    offsetof(Foo__SubMess__SubSubMess, val1),
1792
    NULL,
1793
    &foo__sub_mess__sub_sub_mess__val1__default_value,
1794
    0,             /* flags */
1795
    0,NULL,NULL    /* reserved1,reserved2, etc */
1796
  },
1797
  {
1798
    "bytes1",
1799
    2,
1800
    PROTOBUF_C_LABEL_OPTIONAL,
1801
    PROTOBUF_C_TYPE_BYTES,
1802
    offsetof(Foo__SubMess__SubSubMess, has_bytes1),
1803
    offsetof(Foo__SubMess__SubSubMess, bytes1),
1804
    NULL,
1805
    &foo__sub_mess__sub_sub_mess__bytes1__default_value,
1806
    0,             /* flags */
1807
    0,NULL,NULL    /* reserved1,reserved2, etc */
1808
  },
1809
  {
1810
    "str1",
1811
    3,
1812
    PROTOBUF_C_LABEL_OPTIONAL,
1813
    PROTOBUF_C_TYPE_STRING,
1814
    0,   /* quantifier_offset */
1815
    offsetof(Foo__SubMess__SubSubMess, str1),
1816
    NULL,
1817
    &foo__sub_mess__sub_sub_mess__str1__default_value,
1818
    0,             /* flags */
1819
    0,NULL,NULL    /* reserved1,reserved2, etc */
1820
  },
1821
  {
1822
    "rep",
1823
    4,
1824
    PROTOBUF_C_LABEL_REPEATED,
1825
    PROTOBUF_C_TYPE_INT32,
1826
    offsetof(Foo__SubMess__SubSubMess, n_rep),
1827
    offsetof(Foo__SubMess__SubSubMess, rep),
1828
    NULL,
1829
    NULL,
1830
    0,             /* flags */
1831
    0,NULL,NULL    /* reserved1,reserved2, etc */
1832
  },
1833
  {
1834
    "str2",
1835
    5,
1836
    PROTOBUF_C_LABEL_OPTIONAL,
1837
    PROTOBUF_C_TYPE_BYTES,
1838
    offsetof(Foo__SubMess__SubSubMess, has_str2),
1839
    offsetof(Foo__SubMess__SubSubMess, str2),
1840
    NULL,
1841
    &foo__sub_mess__sub_sub_mess__str2__default_value,
1842
    0,             /* flags */
1843
    0,NULL,NULL    /* reserved1,reserved2, etc */
1844
  },
1845
};
1846
static const unsigned foo__sub_mess__sub_sub_mess__field_indices_by_name[] = {
1847
  1,   /* field[1] = bytes1 */
1848
  3,   /* field[3] = rep */
1849
  2,   /* field[2] = str1 */
1850
  4,   /* field[4] = str2 */
1851
  0,   /* field[0] = val1 */
1852
};
1853
static const ProtobufCIntRange foo__sub_mess__sub_sub_mess__number_ranges[1 + 1] =
1854
{
1855
  { 1, 0 },
1856
  { 0, 5 }
1857
};
1858
const ProtobufCMessageDescriptor foo__sub_mess__sub_sub_mess__descriptor =
1859
{
1860
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1861
  "foo.SubMess.SubSubMess",
1862
  "SubSubMess",
1863
  "Foo__SubMess__SubSubMess",
1864
  "foo",
1865
  sizeof(Foo__SubMess__SubSubMess),
1866
  5,
1867
  foo__sub_mess__sub_sub_mess__field_descriptors,
1868
  foo__sub_mess__sub_sub_mess__field_indices_by_name,
1869
  1,  foo__sub_mess__sub_sub_mess__number_ranges,
1870
  (ProtobufCMessageInit) foo__sub_mess__sub_sub_mess__init,
1871
  NULL,NULL,NULL    /* reserved[123] */
1872
};
1873
static const ProtobufCFieldDescriptor foo__sub_mess__field_descriptors[6] =
1874
{
1875
  {
1876
    "test",
1877
    4,
1878
    PROTOBUF_C_LABEL_REQUIRED,
1879
    PROTOBUF_C_TYPE_INT32,
1880
    0,   /* quantifier_offset */
1881
    offsetof(Foo__SubMess, test),
1882
    NULL,
1883
    NULL,
1884
    0,             /* flags */
1885
    0,NULL,NULL    /* reserved1,reserved2, etc */
1886
  },
1887
  {
1888
    "val1",
1889
    6,
1890
    PROTOBUF_C_LABEL_OPTIONAL,
1891
    PROTOBUF_C_TYPE_INT32,
1892
    offsetof(Foo__SubMess, has_val1),
1893
    offsetof(Foo__SubMess, val1),
1894
    NULL,
1895
    NULL,
1896
    0,             /* flags */
1897
    0,NULL,NULL    /* reserved1,reserved2, etc */
1898
  },
1899
  {
1900
    "val2",
1901
    7,
1902
    PROTOBUF_C_LABEL_OPTIONAL,
1903
    PROTOBUF_C_TYPE_INT32,
1904
    offsetof(Foo__SubMess, has_val2),
1905
    offsetof(Foo__SubMess, val2),
1906
    NULL,
1907
    NULL,
1908
    0,             /* flags */
1909
    0,NULL,NULL    /* reserved1,reserved2, etc */
1910
  },
1911
  {
1912
    "rep",
1913
    8,
1914
    PROTOBUF_C_LABEL_REPEATED,
1915
    PROTOBUF_C_TYPE_INT32,
1916
    offsetof(Foo__SubMess, n_rep),
1917
    offsetof(Foo__SubMess, rep),
1918
    NULL,
1919
    NULL,
1920
    0,             /* flags */
1921
    0,NULL,NULL    /* reserved1,reserved2, etc */
1922
  },
1923
  {
1924
    "sub1",
1925
    9,
1926
    PROTOBUF_C_LABEL_OPTIONAL,
1927
    PROTOBUF_C_TYPE_MESSAGE,
1928
    0,   /* quantifier_offset */
1929
    offsetof(Foo__SubMess, sub1),
1930
    &foo__sub_mess__sub_sub_mess__descriptor,
1931
    NULL,
1932
    0,             /* flags */
1933
    0,NULL,NULL    /* reserved1,reserved2, etc */
1934
  },
1935
  {
1936
    "sub2",
1937
    10,
1938
    PROTOBUF_C_LABEL_OPTIONAL,
1939
    PROTOBUF_C_TYPE_MESSAGE,
1940
    0,   /* quantifier_offset */
1941
    offsetof(Foo__SubMess, sub2),
1942
    &foo__sub_mess__sub_sub_mess__descriptor,
1943
    NULL,
1944
    0,             /* flags */
1945
    0,NULL,NULL    /* reserved1,reserved2, etc */
1946
  },
1947
};
1948
static const unsigned foo__sub_mess__field_indices_by_name[] = {
1949
  3,   /* field[3] = rep */
1950
  4,   /* field[4] = sub1 */
1951
  5,   /* field[5] = sub2 */
1952
  0,   /* field[0] = test */
1953
  1,   /* field[1] = val1 */
1954
  2,   /* field[2] = val2 */
1955
};
1956
static const ProtobufCIntRange foo__sub_mess__number_ranges[2 + 1] =
1957
{
1958
  { 4, 0 },
1959
  { 6, 1 },
1960
  { 0, 6 }
1961
};
1962
const ProtobufCMessageDescriptor foo__sub_mess__descriptor =
1963
{
1964
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1965
  "foo.SubMess",
1966
  "SubMess",
1967
  "Foo__SubMess",
1968
  "foo",
1969
  sizeof(Foo__SubMess),
1970
  6,
1971
  foo__sub_mess__field_descriptors,
1972
  foo__sub_mess__field_indices_by_name,
1973
  2,  foo__sub_mess__number_ranges,
1974
  (ProtobufCMessageInit) foo__sub_mess__init,
1975
  NULL,NULL,NULL    /* reserved[123] */
1976
};
1977
static const ProtobufCFieldDescriptor foo__test_field_no15__field_descriptors[1] =
1978
{
1979
  {
1980
    "test",
1981
    15,
1982
    PROTOBUF_C_LABEL_REQUIRED,
1983
    PROTOBUF_C_TYPE_STRING,
1984
    0,   /* quantifier_offset */
1985
    offsetof(Foo__TestFieldNo15, test),
1986
    NULL,
1987
    NULL,
1988
    0,             /* flags */
1989
    0,NULL,NULL    /* reserved1,reserved2, etc */
1990
  },
1991
};
1992
static const unsigned foo__test_field_no15__field_indices_by_name[] = {
1993
  0,   /* field[0] = test */
1994
};
1995
static const ProtobufCIntRange foo__test_field_no15__number_ranges[1 + 1] =
1996
{
1997
  { 15, 0 },
1998
  { 0, 1 }
1999
};
2000
const ProtobufCMessageDescriptor foo__test_field_no15__descriptor =
2001
{
2002
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2003
  "foo.TestFieldNo15",
2004
  "TestFieldNo15",
2005
  "Foo__TestFieldNo15",
2006
  "foo",
2007
  sizeof(Foo__TestFieldNo15),
2008
  1,
2009
  foo__test_field_no15__field_descriptors,
2010
  foo__test_field_no15__field_indices_by_name,
2011
  1,  foo__test_field_no15__number_ranges,
2012
  (ProtobufCMessageInit) foo__test_field_no15__init,
2013
  NULL,NULL,NULL    /* reserved[123] */
2014
};
2015
static const ProtobufCFieldDescriptor foo__test_field_no16__field_descriptors[1] =
2016
{
2017
  {
2018
    "test",
2019
    16,
2020
    PROTOBUF_C_LABEL_REQUIRED,
2021
    PROTOBUF_C_TYPE_STRING,
2022
    0,   /* quantifier_offset */
2023
    offsetof(Foo__TestFieldNo16, test),
2024
    NULL,
2025
    NULL,
2026
    0,             /* flags */
2027
    0,NULL,NULL    /* reserved1,reserved2, etc */
2028
  },
2029
};
2030
static const unsigned foo__test_field_no16__field_indices_by_name[] = {
2031
  0,   /* field[0] = test */
2032
};
2033
static const ProtobufCIntRange foo__test_field_no16__number_ranges[1 + 1] =
2034
{
2035
  { 16, 0 },
2036
  { 0, 1 }
2037
};
2038
const ProtobufCMessageDescriptor foo__test_field_no16__descriptor =
2039
{
2040
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2041
  "foo.TestFieldNo16",
2042
  "TestFieldNo16",
2043
  "Foo__TestFieldNo16",
2044
  "foo",
2045
  sizeof(Foo__TestFieldNo16),
2046
  1,
2047
  foo__test_field_no16__field_descriptors,
2048
  foo__test_field_no16__field_indices_by_name,
2049
  1,  foo__test_field_no16__number_ranges,
2050
  (ProtobufCMessageInit) foo__test_field_no16__init,
2051
  NULL,NULL,NULL    /* reserved[123] */
2052
};
2053
static const ProtobufCFieldDescriptor foo__test_field_no2047__field_descriptors[1] =
2054
{
2055
  {
2056
    "test",
2057
    2047,
2058
    PROTOBUF_C_LABEL_REQUIRED,
2059
    PROTOBUF_C_TYPE_STRING,
2060
    0,   /* quantifier_offset */
2061
    offsetof(Foo__TestFieldNo2047, test),
2062
    NULL,
2063
    NULL,
2064
    0,             /* flags */
2065
    0,NULL,NULL    /* reserved1,reserved2, etc */
2066
  },
2067
};
2068
static const unsigned foo__test_field_no2047__field_indices_by_name[] = {
2069
  0,   /* field[0] = test */
2070
};
2071
static const ProtobufCIntRange foo__test_field_no2047__number_ranges[1 + 1] =
2072
{
2073
  { 2047, 0 },
2074
  { 0, 1 }
2075
};
2076
const ProtobufCMessageDescriptor foo__test_field_no2047__descriptor =
2077
{
2078
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2079
  "foo.TestFieldNo2047",
2080
  "TestFieldNo2047",
2081
  "Foo__TestFieldNo2047",
2082
  "foo",
2083
  sizeof(Foo__TestFieldNo2047),
2084
  1,
2085
  foo__test_field_no2047__field_descriptors,
2086
  foo__test_field_no2047__field_indices_by_name,
2087
  1,  foo__test_field_no2047__number_ranges,
2088
  (ProtobufCMessageInit) foo__test_field_no2047__init,
2089
  NULL,NULL,NULL    /* reserved[123] */
2090
};
2091
static const ProtobufCFieldDescriptor foo__test_field_no2048__field_descriptors[1] =
2092
{
2093
  {
2094
    "test",
2095
    2048,
2096
    PROTOBUF_C_LABEL_REQUIRED,
2097
    PROTOBUF_C_TYPE_STRING,
2098
    0,   /* quantifier_offset */
2099
    offsetof(Foo__TestFieldNo2048, test),
2100
    NULL,
2101
    NULL,
2102
    0,             /* flags */
2103
    0,NULL,NULL    /* reserved1,reserved2, etc */
2104
  },
2105
};
2106
static const unsigned foo__test_field_no2048__field_indices_by_name[] = {
2107
  0,   /* field[0] = test */
2108
};
2109
static const ProtobufCIntRange foo__test_field_no2048__number_ranges[1 + 1] =
2110
{
2111
  { 2048, 0 },
2112
  { 0, 1 }
2113
};
2114
const ProtobufCMessageDescriptor foo__test_field_no2048__descriptor =
2115
{
2116
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2117
  "foo.TestFieldNo2048",
2118
  "TestFieldNo2048",
2119
  "Foo__TestFieldNo2048",
2120
  "foo",
2121
  sizeof(Foo__TestFieldNo2048),
2122
  1,
2123
  foo__test_field_no2048__field_descriptors,
2124
  foo__test_field_no2048__field_indices_by_name,
2125
  1,  foo__test_field_no2048__number_ranges,
2126
  (ProtobufCMessageInit) foo__test_field_no2048__init,
2127
  NULL,NULL,NULL    /* reserved[123] */
2128
};
2129
static const ProtobufCFieldDescriptor foo__test_field_no262143__field_descriptors[1] =
2130
{
2131
  {
2132
    "test",
2133
    262143,
2134
    PROTOBUF_C_LABEL_REQUIRED,
2135
    PROTOBUF_C_TYPE_STRING,
2136
    0,   /* quantifier_offset */
2137
    offsetof(Foo__TestFieldNo262143, test),
2138
    NULL,
2139
    NULL,
2140
    0,             /* flags */
2141
    0,NULL,NULL    /* reserved1,reserved2, etc */
2142
  },
2143
};
2144
static const unsigned foo__test_field_no262143__field_indices_by_name[] = {
2145
  0,   /* field[0] = test */
2146
};
2147
static const ProtobufCIntRange foo__test_field_no262143__number_ranges[1 + 1] =
2148
{
2149
  { 262143, 0 },
2150
  { 0, 1 }
2151
};
2152
const ProtobufCMessageDescriptor foo__test_field_no262143__descriptor =
2153
{
2154
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2155
  "foo.TestFieldNo262143",
2156
  "TestFieldNo262143",
2157
  "Foo__TestFieldNo262143",
2158
  "foo",
2159
  sizeof(Foo__TestFieldNo262143),
2160
  1,
2161
  foo__test_field_no262143__field_descriptors,
2162
  foo__test_field_no262143__field_indices_by_name,
2163
  1,  foo__test_field_no262143__number_ranges,
2164
  (ProtobufCMessageInit) foo__test_field_no262143__init,
2165
  NULL,NULL,NULL    /* reserved[123] */
2166
};
2167
static const ProtobufCFieldDescriptor foo__test_field_no262144__field_descriptors[1] =
2168
{
2169
  {
2170
    "test",
2171
    262144,
2172
    PROTOBUF_C_LABEL_REQUIRED,
2173
    PROTOBUF_C_TYPE_STRING,
2174
    0,   /* quantifier_offset */
2175
    offsetof(Foo__TestFieldNo262144, test),
2176
    NULL,
2177
    NULL,
2178
    0,             /* flags */
2179
    0,NULL,NULL    /* reserved1,reserved2, etc */
2180
  },
2181
};
2182
static const unsigned foo__test_field_no262144__field_indices_by_name[] = {
2183
  0,   /* field[0] = test */
2184
};
2185
static const ProtobufCIntRange foo__test_field_no262144__number_ranges[1 + 1] =
2186
{
2187
  { 262144, 0 },
2188
  { 0, 1 }
2189
};
2190
const ProtobufCMessageDescriptor foo__test_field_no262144__descriptor =
2191
{
2192
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2193
  "foo.TestFieldNo262144",
2194
  "TestFieldNo262144",
2195
  "Foo__TestFieldNo262144",
2196
  "foo",
2197
  sizeof(Foo__TestFieldNo262144),
2198
  1,
2199
  foo__test_field_no262144__field_descriptors,
2200
  foo__test_field_no262144__field_indices_by_name,
2201
  1,  foo__test_field_no262144__number_ranges,
2202
  (ProtobufCMessageInit) foo__test_field_no262144__init,
2203
  NULL,NULL,NULL    /* reserved[123] */
2204
};
2205
static const ProtobufCFieldDescriptor foo__test_field_no33554431__field_descriptors[1] =
2206
{
2207
  {
2208
    "test",
2209
    33554431,
2210
    PROTOBUF_C_LABEL_REQUIRED,
2211
    PROTOBUF_C_TYPE_STRING,
2212
    0,   /* quantifier_offset */
2213
    offsetof(Foo__TestFieldNo33554431, test),
2214
    NULL,
2215
    NULL,
2216
    0,             /* flags */
2217
    0,NULL,NULL    /* reserved1,reserved2, etc */
2218
  },
2219
};
2220
static const unsigned foo__test_field_no33554431__field_indices_by_name[] = {
2221
  0,   /* field[0] = test */
2222
};
2223
static const ProtobufCIntRange foo__test_field_no33554431__number_ranges[1 + 1] =
2224
{
2225
  { 33554431, 0 },
2226
  { 0, 1 }
2227
};
2228
const ProtobufCMessageDescriptor foo__test_field_no33554431__descriptor =
2229
{
2230
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2231
  "foo.TestFieldNo33554431",
2232
  "TestFieldNo33554431",
2233
  "Foo__TestFieldNo33554431",
2234
  "foo",
2235
  sizeof(Foo__TestFieldNo33554431),
2236
  1,
2237
  foo__test_field_no33554431__field_descriptors,
2238
  foo__test_field_no33554431__field_indices_by_name,
2239
  1,  foo__test_field_no33554431__number_ranges,
2240
  (ProtobufCMessageInit) foo__test_field_no33554431__init,
2241
  NULL,NULL,NULL    /* reserved[123] */
2242
};
2243
static const ProtobufCFieldDescriptor foo__test_field_no33554432__field_descriptors[1] =
2244
{
2245
  {
2246
    "test",
2247
    33554432,
2248
    PROTOBUF_C_LABEL_REQUIRED,
2249
    PROTOBUF_C_TYPE_STRING,
2250
    0,   /* quantifier_offset */
2251
    offsetof(Foo__TestFieldNo33554432, test),
2252
    NULL,
2253
    NULL,
2254
    0,             /* flags */
2255
    0,NULL,NULL    /* reserved1,reserved2, etc */
2256
  },
2257
};
2258
static const unsigned foo__test_field_no33554432__field_indices_by_name[] = {
2259
  0,   /* field[0] = test */
2260
};
2261
static const ProtobufCIntRange foo__test_field_no33554432__number_ranges[1 + 1] =
2262
{
2263
  { 33554432, 0 },
2264
  { 0, 1 }
2265
};
2266
const ProtobufCMessageDescriptor foo__test_field_no33554432__descriptor =
2267
{
2268
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2269
  "foo.TestFieldNo33554432",
2270
  "TestFieldNo33554432",
2271
  "Foo__TestFieldNo33554432",
2272
  "foo",
2273
  sizeof(Foo__TestFieldNo33554432),
2274
  1,
2275
  foo__test_field_no33554432__field_descriptors,
2276
  foo__test_field_no33554432__field_indices_by_name,
2277
  1,  foo__test_field_no33554432__number_ranges,
2278
  (ProtobufCMessageInit) foo__test_field_no33554432__init,
2279
  NULL,NULL,NULL    /* reserved[123] */
2280
};
2281
static const ProtobufCFieldDescriptor foo__test_mess__field_descriptors[18] =
2282
{
2283
  {
2284
    "test_int32",
2285
    1,
2286
    PROTOBUF_C_LABEL_REPEATED,
2287
    PROTOBUF_C_TYPE_INT32,
2288
    offsetof(Foo__TestMess, n_test_int32),
2289
    offsetof(Foo__TestMess, test_int32),
2290
    NULL,
2291
    NULL,
2292
    0,             /* flags */
2293
    0,NULL,NULL    /* reserved1,reserved2, etc */
2294
  },
2295
  {
2296
    "test_sint32",
2297
    2,
2298
    PROTOBUF_C_LABEL_REPEATED,
2299
    PROTOBUF_C_TYPE_SINT32,
2300
    offsetof(Foo__TestMess, n_test_sint32),
2301
    offsetof(Foo__TestMess, test_sint32),
2302
    NULL,
2303
    NULL,
2304
    0,             /* flags */
2305
    0,NULL,NULL    /* reserved1,reserved2, etc */
2306
  },
2307
  {
2308
    "test_sfixed32",
2309
    3,
2310
    PROTOBUF_C_LABEL_REPEATED,
2311
    PROTOBUF_C_TYPE_SFIXED32,
2312
    offsetof(Foo__TestMess, n_test_sfixed32),
2313
    offsetof(Foo__TestMess, test_sfixed32),
2314
    NULL,
2315
    NULL,
2316
    0,             /* flags */
2317
    0,NULL,NULL    /* reserved1,reserved2, etc */
2318
  },
2319
  {
2320
    "test_int64",
2321
    4,
2322
    PROTOBUF_C_LABEL_REPEATED,
2323
    PROTOBUF_C_TYPE_INT64,
2324
    offsetof(Foo__TestMess, n_test_int64),
2325
    offsetof(Foo__TestMess, test_int64),
2326
    NULL,
2327
    NULL,
2328
    0,             /* flags */
2329
    0,NULL,NULL    /* reserved1,reserved2, etc */
2330
  },
2331
  {
2332
    "test_sint64",
2333
    5,
2334
    PROTOBUF_C_LABEL_REPEATED,
2335
    PROTOBUF_C_TYPE_SINT64,
2336
    offsetof(Foo__TestMess, n_test_sint64),
2337
    offsetof(Foo__TestMess, test_sint64),
2338
    NULL,
2339
    NULL,
2340
    0,             /* flags */
2341
    0,NULL,NULL    /* reserved1,reserved2, etc */
2342
  },
2343
  {
2344
    "test_sfixed64",
2345
    6,
2346
    PROTOBUF_C_LABEL_REPEATED,
2347
    PROTOBUF_C_TYPE_SFIXED64,
2348
    offsetof(Foo__TestMess, n_test_sfixed64),
2349
    offsetof(Foo__TestMess, test_sfixed64),
2350
    NULL,
2351
    NULL,
2352
    0,             /* flags */
2353
    0,NULL,NULL    /* reserved1,reserved2, etc */
2354
  },
2355
  {
2356
    "test_uint32",
2357
    7,
2358
    PROTOBUF_C_LABEL_REPEATED,
2359
    PROTOBUF_C_TYPE_UINT32,
2360
    offsetof(Foo__TestMess, n_test_uint32),
2361
    offsetof(Foo__TestMess, test_uint32),
2362
    NULL,
2363
    NULL,
2364
    0,             /* flags */
2365
    0,NULL,NULL    /* reserved1,reserved2, etc */
2366
  },
2367
  {
2368
    "test_fixed32",
2369
    8,
2370
    PROTOBUF_C_LABEL_REPEATED,
2371
    PROTOBUF_C_TYPE_FIXED32,
2372
    offsetof(Foo__TestMess, n_test_fixed32),
2373
    offsetof(Foo__TestMess, test_fixed32),
2374
    NULL,
2375
    NULL,
2376
    0,             /* flags */
2377
    0,NULL,NULL    /* reserved1,reserved2, etc */
2378
  },
2379
  {
2380
    "test_uint64",
2381
    9,
2382
    PROTOBUF_C_LABEL_REPEATED,
2383
    PROTOBUF_C_TYPE_UINT64,
2384
    offsetof(Foo__TestMess, n_test_uint64),
2385
    offsetof(Foo__TestMess, test_uint64),
2386
    NULL,
2387
    NULL,
2388
    0,             /* flags */
2389
    0,NULL,NULL    /* reserved1,reserved2, etc */
2390
  },
2391
  {
2392
    "test_fixed64",
2393
    10,
2394
    PROTOBUF_C_LABEL_REPEATED,
2395
    PROTOBUF_C_TYPE_FIXED64,
2396
    offsetof(Foo__TestMess, n_test_fixed64),
2397
    offsetof(Foo__TestMess, test_fixed64),
2398
    NULL,
2399
    NULL,
2400
    0,             /* flags */
2401
    0,NULL,NULL    /* reserved1,reserved2, etc */
2402
  },
2403
  {
2404
    "test_float",
2405
    11,
2406
    PROTOBUF_C_LABEL_REPEATED,
2407
    PROTOBUF_C_TYPE_FLOAT,
2408
    offsetof(Foo__TestMess, n_test_float),
2409
    offsetof(Foo__TestMess, test_float),
2410
    NULL,
2411
    NULL,
2412
    0,             /* flags */
2413
    0,NULL,NULL    /* reserved1,reserved2, etc */
2414
  },
2415
  {
2416
    "test_double",
2417
    12,
2418
    PROTOBUF_C_LABEL_REPEATED,
2419
    PROTOBUF_C_TYPE_DOUBLE,
2420
    offsetof(Foo__TestMess, n_test_double),
2421
    offsetof(Foo__TestMess, test_double),
2422
    NULL,
2423
    NULL,
2424
    0,             /* flags */
2425
    0,NULL,NULL    /* reserved1,reserved2, etc */
2426
  },
2427
  {
2428
    "test_boolean",
2429
    13,
2430
    PROTOBUF_C_LABEL_REPEATED,
2431
    PROTOBUF_C_TYPE_BOOL,
2432
    offsetof(Foo__TestMess, n_test_boolean),
2433
    offsetof(Foo__TestMess, test_boolean),
2434
    NULL,
2435
    NULL,
2436
    0,             /* flags */
2437
    0,NULL,NULL    /* reserved1,reserved2, etc */
2438
  },
2439
  {
2440
    "test_enum_small",
2441
    14,
2442
    PROTOBUF_C_LABEL_REPEATED,
2443
    PROTOBUF_C_TYPE_ENUM,
2444
    offsetof(Foo__TestMess, n_test_enum_small),
2445
    offsetof(Foo__TestMess, test_enum_small),
2446
    &foo__test_enum_small__descriptor,
2447
    NULL,
2448
    0,             /* flags */
2449
    0,NULL,NULL    /* reserved1,reserved2, etc */
2450
  },
2451
  {
2452
    "test_enum",
2453
    15,
2454
    PROTOBUF_C_LABEL_REPEATED,
2455
    PROTOBUF_C_TYPE_ENUM,
2456
    offsetof(Foo__TestMess, n_test_enum),
2457
    offsetof(Foo__TestMess, test_enum),
2458
    &foo__test_enum__descriptor,
2459
    NULL,
2460
    0,             /* flags */
2461
    0,NULL,NULL    /* reserved1,reserved2, etc */
2462
  },
2463
  {
2464
    "test_string",
2465
    16,
2466
    PROTOBUF_C_LABEL_REPEATED,
2467
    PROTOBUF_C_TYPE_STRING,
2468
    offsetof(Foo__TestMess, n_test_string),
2469
    offsetof(Foo__TestMess, test_string),
2470
    NULL,
2471
    NULL,
2472
    0,             /* flags */
2473
    0,NULL,NULL    /* reserved1,reserved2, etc */
2474
  },
2475
  {
2476
    "test_bytes",
2477
    17,
2478
    PROTOBUF_C_LABEL_REPEATED,
2479
    PROTOBUF_C_TYPE_BYTES,
2480
    offsetof(Foo__TestMess, n_test_bytes),
2481
    offsetof(Foo__TestMess, test_bytes),
2482
    NULL,
2483
    NULL,
2484
    0,             /* flags */
2485
    0,NULL,NULL    /* reserved1,reserved2, etc */
2486
  },
2487
  {
2488
    "test_message",
2489
    18,
2490
    PROTOBUF_C_LABEL_REPEATED,
2491
    PROTOBUF_C_TYPE_MESSAGE,
2492
    offsetof(Foo__TestMess, n_test_message),
2493
    offsetof(Foo__TestMess, test_message),
2494
    &foo__sub_mess__descriptor,
2495
    NULL,
2496
    0,             /* flags */
2497
    0,NULL,NULL    /* reserved1,reserved2, etc */
2498
  },
2499
};
2500
static const unsigned foo__test_mess__field_indices_by_name[] = {
2501
  12,   /* field[12] = test_boolean */
2502
  16,   /* field[16] = test_bytes */
2503
  11,   /* field[11] = test_double */
2504
  14,   /* field[14] = test_enum */
2505
  13,   /* field[13] = test_enum_small */
2506
  7,   /* field[7] = test_fixed32 */
2507
  9,   /* field[9] = test_fixed64 */
2508
  10,   /* field[10] = test_float */
2509
  0,   /* field[0] = test_int32 */
2510
  3,   /* field[3] = test_int64 */
2511
  17,   /* field[17] = test_message */
2512
  2,   /* field[2] = test_sfixed32 */
2513
  5,   /* field[5] = test_sfixed64 */
2514
  1,   /* field[1] = test_sint32 */
2515
  4,   /* field[4] = test_sint64 */
2516
  15,   /* field[15] = test_string */
2517
  6,   /* field[6] = test_uint32 */
2518
  8,   /* field[8] = test_uint64 */
2519
};
2520
static const ProtobufCIntRange foo__test_mess__number_ranges[1 + 1] =
2521
{
2522
  { 1, 0 },
2523
  { 0, 18 }
2524
};
2525
const ProtobufCMessageDescriptor foo__test_mess__descriptor =
2526
{
2527
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2528
  "foo.TestMess",
2529
  "TestMess",
2530
  "Foo__TestMess",
2531
  "foo",
2532
  sizeof(Foo__TestMess),
2533
  18,
2534
  foo__test_mess__field_descriptors,
2535
  foo__test_mess__field_indices_by_name,
2536
  1,  foo__test_mess__number_ranges,
2537
  (ProtobufCMessageInit) foo__test_mess__init,
2538
  NULL,NULL,NULL    /* reserved[123] */
2539
};
2540
static const ProtobufCFieldDescriptor foo__test_mess_packed__field_descriptors[15] =
2541
{
2542
  {
2543
    "test_int32",
2544
    1,
2545
    PROTOBUF_C_LABEL_REPEATED,
2546
    PROTOBUF_C_TYPE_INT32,
2547
    offsetof(Foo__TestMessPacked, n_test_int32),
2548
    offsetof(Foo__TestMessPacked, test_int32),
2549
    NULL,
2550
    NULL,
2551
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
2552
    0,NULL,NULL    /* reserved1,reserved2, etc */
2553
  },
2554
  {
2555
    "test_sint32",
2556
    2,
2557
    PROTOBUF_C_LABEL_REPEATED,
2558
    PROTOBUF_C_TYPE_SINT32,
2559
    offsetof(Foo__TestMessPacked, n_test_sint32),
2560
    offsetof(Foo__TestMessPacked, test_sint32),
2561
    NULL,
2562
    NULL,
2563
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
2564
    0,NULL,NULL    /* reserved1,reserved2, etc */
2565
  },
2566
  {
2567
    "test_sfixed32",
2568
    3,
2569
    PROTOBUF_C_LABEL_REPEATED,
2570
    PROTOBUF_C_TYPE_SFIXED32,
2571
    offsetof(Foo__TestMessPacked, n_test_sfixed32),
2572
    offsetof(Foo__TestMessPacked, test_sfixed32),
2573
    NULL,
2574
    NULL,
2575
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
2576
    0,NULL,NULL    /* reserved1,reserved2, etc */
2577
  },
2578
  {
2579
    "test_int64",
2580
    4,
2581
    PROTOBUF_C_LABEL_REPEATED,
2582
    PROTOBUF_C_TYPE_INT64,
2583
    offsetof(Foo__TestMessPacked, n_test_int64),
2584
    offsetof(Foo__TestMessPacked, test_int64),
2585
    NULL,
2586
    NULL,
2587
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
2588
    0,NULL,NULL    /* reserved1,reserved2, etc */
2589
  },
2590
  {
2591
    "test_sint64",
2592
    5,
2593
    PROTOBUF_C_LABEL_REPEATED,
2594
    PROTOBUF_C_TYPE_SINT64,
2595
    offsetof(Foo__TestMessPacked, n_test_sint64),
2596
    offsetof(Foo__TestMessPacked, test_sint64),
2597
    NULL,
2598
    NULL,
2599
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
2600
    0,NULL,NULL    /* reserved1,reserved2, etc */
2601
  },
2602
  {
2603
    "test_sfixed64",
2604
    6,
2605
    PROTOBUF_C_LABEL_REPEATED,
2606
    PROTOBUF_C_TYPE_SFIXED64,
2607
    offsetof(Foo__TestMessPacked, n_test_sfixed64),
2608
    offsetof(Foo__TestMessPacked, test_sfixed64),
2609
    NULL,
2610
    NULL,
2611
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
2612
    0,NULL,NULL    /* reserved1,reserved2, etc */
2613
  },
2614
  {
2615
    "test_uint32",
2616
    7,
2617
    PROTOBUF_C_LABEL_REPEATED,
2618
    PROTOBUF_C_TYPE_UINT32,
2619
    offsetof(Foo__TestMessPacked, n_test_uint32),
2620
    offsetof(Foo__TestMessPacked, test_uint32),
2621
    NULL,
2622
    NULL,
2623
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
2624
    0,NULL,NULL    /* reserved1,reserved2, etc */
2625
  },
2626
  {
2627
    "test_fixed32",
2628
    8,
2629
    PROTOBUF_C_LABEL_REPEATED,
2630
    PROTOBUF_C_TYPE_FIXED32,
2631
    offsetof(Foo__TestMessPacked, n_test_fixed32),
2632
    offsetof(Foo__TestMessPacked, test_fixed32),
2633
    NULL,
2634
    NULL,
2635
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
2636
    0,NULL,NULL    /* reserved1,reserved2, etc */
2637
  },
2638
  {
2639
    "test_uint64",
2640
    9,
2641
    PROTOBUF_C_LABEL_REPEATED,
2642
    PROTOBUF_C_TYPE_UINT64,
2643
    offsetof(Foo__TestMessPacked, n_test_uint64),
2644
    offsetof(Foo__TestMessPacked, test_uint64),
2645
    NULL,
2646
    NULL,
2647
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
2648
    0,NULL,NULL    /* reserved1,reserved2, etc */
2649
  },
2650
  {
2651
    "test_fixed64",
2652
    10,
2653
    PROTOBUF_C_LABEL_REPEATED,
2654
    PROTOBUF_C_TYPE_FIXED64,
2655
    offsetof(Foo__TestMessPacked, n_test_fixed64),
2656
    offsetof(Foo__TestMessPacked, test_fixed64),
2657
    NULL,
2658
    NULL,
2659
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
2660
    0,NULL,NULL    /* reserved1,reserved2, etc */
2661
  },
2662
  {
2663
    "test_float",
2664
    11,
2665
    PROTOBUF_C_LABEL_REPEATED,
2666
    PROTOBUF_C_TYPE_FLOAT,
2667
    offsetof(Foo__TestMessPacked, n_test_float),
2668
    offsetof(Foo__TestMessPacked, test_float),
2669
    NULL,
2670
    NULL,
2671
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
2672
    0,NULL,NULL    /* reserved1,reserved2, etc */
2673
  },
2674
  {
2675
    "test_double",
2676
    12,
2677
    PROTOBUF_C_LABEL_REPEATED,
2678
    PROTOBUF_C_TYPE_DOUBLE,
2679
    offsetof(Foo__TestMessPacked, n_test_double),
2680
    offsetof(Foo__TestMessPacked, test_double),
2681
    NULL,
2682
    NULL,
2683
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
2684
    0,NULL,NULL    /* reserved1,reserved2, etc */
2685
  },
2686
  {
2687
    "test_boolean",
2688
    13,
2689
    PROTOBUF_C_LABEL_REPEATED,
2690
    PROTOBUF_C_TYPE_BOOL,
2691
    offsetof(Foo__TestMessPacked, n_test_boolean),
2692
    offsetof(Foo__TestMessPacked, test_boolean),
2693
    NULL,
2694
    NULL,
2695
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
2696
    0,NULL,NULL    /* reserved1,reserved2, etc */
2697
  },
2698
  {
2699
    "test_enum_small",
2700
    14,
2701
    PROTOBUF_C_LABEL_REPEATED,
2702
    PROTOBUF_C_TYPE_ENUM,
2703
    offsetof(Foo__TestMessPacked, n_test_enum_small),
2704
    offsetof(Foo__TestMessPacked, test_enum_small),
2705
    &foo__test_enum_small__descriptor,
2706
    NULL,
2707
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
2708
    0,NULL,NULL    /* reserved1,reserved2, etc */
2709
  },
2710
  {
2711
    "test_enum",
2712
    15,
2713
    PROTOBUF_C_LABEL_REPEATED,
2714
    PROTOBUF_C_TYPE_ENUM,
2715
    offsetof(Foo__TestMessPacked, n_test_enum),
2716
    offsetof(Foo__TestMessPacked, test_enum),
2717
    &foo__test_enum__descriptor,
2718
    NULL,
2719
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
2720
    0,NULL,NULL    /* reserved1,reserved2, etc */
2721
  },
2722
};
2723
static const unsigned foo__test_mess_packed__field_indices_by_name[] = {
2724
  12,   /* field[12] = test_boolean */
2725
  11,   /* field[11] = test_double */
2726
  14,   /* field[14] = test_enum */
2727
  13,   /* field[13] = test_enum_small */
2728
  7,   /* field[7] = test_fixed32 */
2729
  9,   /* field[9] = test_fixed64 */
2730
  10,   /* field[10] = test_float */
2731
  0,   /* field[0] = test_int32 */
2732
  3,   /* field[3] = test_int64 */
2733
  2,   /* field[2] = test_sfixed32 */
2734
  5,   /* field[5] = test_sfixed64 */
2735
  1,   /* field[1] = test_sint32 */
2736
  4,   /* field[4] = test_sint64 */
2737
  6,   /* field[6] = test_uint32 */
2738
  8,   /* field[8] = test_uint64 */
2739
};
2740
static const ProtobufCIntRange foo__test_mess_packed__number_ranges[1 + 1] =
2741
{
2742
  { 1, 0 },
2743
  { 0, 15 }
2744
};
2745
const ProtobufCMessageDescriptor foo__test_mess_packed__descriptor =
2746
{
2747
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2748
  "foo.TestMessPacked",
2749
  "TestMessPacked",
2750
  "Foo__TestMessPacked",
2751
  "foo",
2752
  sizeof(Foo__TestMessPacked),
2753
  15,
2754
  foo__test_mess_packed__field_descriptors,
2755
  foo__test_mess_packed__field_indices_by_name,
2756
  1,  foo__test_mess_packed__number_ranges,
2757
  (ProtobufCMessageInit) foo__test_mess_packed__init,
2758
  NULL,NULL,NULL    /* reserved[123] */
2759
};
2760
static const ProtobufCFieldDescriptor foo__test_mess_optional__field_descriptors[18] =
2761
{
2762
  {
2763
    "test_int32",
2764
    1,
2765
    PROTOBUF_C_LABEL_OPTIONAL,
2766
    PROTOBUF_C_TYPE_INT32,
2767
    offsetof(Foo__TestMessOptional, has_test_int32),
2768
    offsetof(Foo__TestMessOptional, test_int32),
2769
    NULL,
2770
    NULL,
2771
    0,             /* flags */
2772
    0,NULL,NULL    /* reserved1,reserved2, etc */
2773
  },
2774
  {
2775
    "test_sint32",
2776
    2,
2777
    PROTOBUF_C_LABEL_OPTIONAL,
2778
    PROTOBUF_C_TYPE_SINT32,
2779
    offsetof(Foo__TestMessOptional, has_test_sint32),
2780
    offsetof(Foo__TestMessOptional, test_sint32),
2781
    NULL,
2782
    NULL,
2783
    0,             /* flags */
2784
    0,NULL,NULL    /* reserved1,reserved2, etc */
2785
  },
2786
  {
2787
    "test_sfixed32",
2788
    3,
2789
    PROTOBUF_C_LABEL_OPTIONAL,
2790
    PROTOBUF_C_TYPE_SFIXED32,
2791
    offsetof(Foo__TestMessOptional, has_test_sfixed32),
2792
    offsetof(Foo__TestMessOptional, test_sfixed32),
2793
    NULL,
2794
    NULL,
2795
    0,             /* flags */
2796
    0,NULL,NULL    /* reserved1,reserved2, etc */
2797
  },
2798
  {
2799
    "test_int64",
2800
    4,
2801
    PROTOBUF_C_LABEL_OPTIONAL,
2802
    PROTOBUF_C_TYPE_INT64,
2803
    offsetof(Foo__TestMessOptional, has_test_int64),
2804
    offsetof(Foo__TestMessOptional, test_int64),
2805
    NULL,
2806
    NULL,
2807
    0,             /* flags */
2808
    0,NULL,NULL    /* reserved1,reserved2, etc */
2809
  },
2810
  {
2811
    "test_sint64",
2812
    5,
2813
    PROTOBUF_C_LABEL_OPTIONAL,
2814
    PROTOBUF_C_TYPE_SINT64,
2815
    offsetof(Foo__TestMessOptional, has_test_sint64),
2816
    offsetof(Foo__TestMessOptional, test_sint64),
2817
    NULL,
2818
    NULL,
2819
    0,             /* flags */
2820
    0,NULL,NULL    /* reserved1,reserved2, etc */
2821
  },
2822
  {
2823
    "test_sfixed64",
2824
    6,
2825
    PROTOBUF_C_LABEL_OPTIONAL,
2826
    PROTOBUF_C_TYPE_SFIXED64,
2827
    offsetof(Foo__TestMessOptional, has_test_sfixed64),
2828
    offsetof(Foo__TestMessOptional, test_sfixed64),
2829
    NULL,
2830
    NULL,
2831
    0,             /* flags */
2832
    0,NULL,NULL    /* reserved1,reserved2, etc */
2833
  },
2834
  {
2835
    "test_uint32",
2836
    7,
2837
    PROTOBUF_C_LABEL_OPTIONAL,
2838
    PROTOBUF_C_TYPE_UINT32,
2839
    offsetof(Foo__TestMessOptional, has_test_uint32),
2840
    offsetof(Foo__TestMessOptional, test_uint32),
2841
    NULL,
2842
    NULL,
2843
    0,             /* flags */
2844
    0,NULL,NULL    /* reserved1,reserved2, etc */
2845
  },
2846
  {
2847
    "test_fixed32",
2848
    8,
2849
    PROTOBUF_C_LABEL_OPTIONAL,
2850
    PROTOBUF_C_TYPE_FIXED32,
2851
    offsetof(Foo__TestMessOptional, has_test_fixed32),
2852
    offsetof(Foo__TestMessOptional, test_fixed32),
2853
    NULL,
2854
    NULL,
2855
    0,             /* flags */
2856
    0,NULL,NULL    /* reserved1,reserved2, etc */
2857
  },
2858
  {
2859
    "test_uint64",
2860
    9,
2861
    PROTOBUF_C_LABEL_OPTIONAL,
2862
    PROTOBUF_C_TYPE_UINT64,
2863
    offsetof(Foo__TestMessOptional, has_test_uint64),
2864
    offsetof(Foo__TestMessOptional, test_uint64),
2865
    NULL,
2866
    NULL,
2867
    0,             /* flags */
2868
    0,NULL,NULL    /* reserved1,reserved2, etc */
2869
  },
2870
  {
2871
    "test_fixed64",
2872
    10,
2873
    PROTOBUF_C_LABEL_OPTIONAL,
2874
    PROTOBUF_C_TYPE_FIXED64,
2875
    offsetof(Foo__TestMessOptional, has_test_fixed64),
2876
    offsetof(Foo__TestMessOptional, test_fixed64),
2877
    NULL,
2878
    NULL,
2879
    0,             /* flags */
2880
    0,NULL,NULL    /* reserved1,reserved2, etc */
2881
  },
2882
  {
2883
    "test_float",
2884
    11,
2885
    PROTOBUF_C_LABEL_OPTIONAL,
2886
    PROTOBUF_C_TYPE_FLOAT,
2887
    offsetof(Foo__TestMessOptional, has_test_float),
2888
    offsetof(Foo__TestMessOptional, test_float),
2889
    NULL,
2890
    NULL,
2891
    0,             /* flags */
2892
    0,NULL,NULL    /* reserved1,reserved2, etc */
2893
  },
2894
  {
2895
    "test_double",
2896
    12,
2897
    PROTOBUF_C_LABEL_OPTIONAL,
2898
    PROTOBUF_C_TYPE_DOUBLE,
2899
    offsetof(Foo__TestMessOptional, has_test_double),
2900
    offsetof(Foo__TestMessOptional, test_double),
2901
    NULL,
2902
    NULL,
2903
    0,             /* flags */
2904
    0,NULL,NULL    /* reserved1,reserved2, etc */
2905
  },
2906
  {
2907
    "test_boolean",
2908
    13,
2909
    PROTOBUF_C_LABEL_OPTIONAL,
2910
    PROTOBUF_C_TYPE_BOOL,
2911
    offsetof(Foo__TestMessOptional, has_test_boolean),
2912
    offsetof(Foo__TestMessOptional, test_boolean),
2913
    NULL,
2914
    NULL,
2915
    0,             /* flags */
2916
    0,NULL,NULL    /* reserved1,reserved2, etc */
2917
  },
2918
  {
2919
    "test_enum_small",
2920
    14,
2921
    PROTOBUF_C_LABEL_OPTIONAL,
2922
    PROTOBUF_C_TYPE_ENUM,
2923
    offsetof(Foo__TestMessOptional, has_test_enum_small),
2924
    offsetof(Foo__TestMessOptional, test_enum_small),
2925
    &foo__test_enum_small__descriptor,
2926
    NULL,
2927
    0,             /* flags */
2928
    0,NULL,NULL    /* reserved1,reserved2, etc */
2929
  },
2930
  {
2931
    "test_enum",
2932
    15,
2933
    PROTOBUF_C_LABEL_OPTIONAL,
2934
    PROTOBUF_C_TYPE_ENUM,
2935
    offsetof(Foo__TestMessOptional, has_test_enum),
2936
    offsetof(Foo__TestMessOptional, test_enum),
2937
    &foo__test_enum__descriptor,
2938
    NULL,
2939
    0,             /* flags */
2940
    0,NULL,NULL    /* reserved1,reserved2, etc */
2941
  },
2942
  {
2943
    "test_string",
2944
    16,
2945
    PROTOBUF_C_LABEL_OPTIONAL,
2946
    PROTOBUF_C_TYPE_STRING,
2947
    0,   /* quantifier_offset */
2948
    offsetof(Foo__TestMessOptional, test_string),
2949
    NULL,
2950
    NULL,
2951
    0,             /* flags */
2952
    0,NULL,NULL    /* reserved1,reserved2, etc */
2953
  },
2954
  {
2955
    "test_bytes",
2956
    17,
2957
    PROTOBUF_C_LABEL_OPTIONAL,
2958
    PROTOBUF_C_TYPE_BYTES,
2959
    offsetof(Foo__TestMessOptional, has_test_bytes),
2960
    offsetof(Foo__TestMessOptional, test_bytes),
2961
    NULL,
2962
    NULL,
2963
    0,             /* flags */
2964
    0,NULL,NULL    /* reserved1,reserved2, etc */
2965
  },
2966
  {
2967
    "test_message",
2968
    18,
2969
    PROTOBUF_C_LABEL_OPTIONAL,
2970
    PROTOBUF_C_TYPE_MESSAGE,
2971
    0,   /* quantifier_offset */
2972
    offsetof(Foo__TestMessOptional, test_message),
2973
    &foo__sub_mess__descriptor,
2974
    NULL,
2975
    0,             /* flags */
2976
    0,NULL,NULL    /* reserved1,reserved2, etc */
2977
  },
2978
};
2979
static const unsigned foo__test_mess_optional__field_indices_by_name[] = {
2980
  12,   /* field[12] = test_boolean */
2981
  16,   /* field[16] = test_bytes */
2982
  11,   /* field[11] = test_double */
2983
  14,   /* field[14] = test_enum */
2984
  13,   /* field[13] = test_enum_small */
2985
  7,   /* field[7] = test_fixed32 */
2986
  9,   /* field[9] = test_fixed64 */
2987
  10,   /* field[10] = test_float */
2988
  0,   /* field[0] = test_int32 */
2989
  3,   /* field[3] = test_int64 */
2990
  17,   /* field[17] = test_message */
2991
  2,   /* field[2] = test_sfixed32 */
2992
  5,   /* field[5] = test_sfixed64 */
2993
  1,   /* field[1] = test_sint32 */
2994
  4,   /* field[4] = test_sint64 */
2995
  15,   /* field[15] = test_string */
2996
  6,   /* field[6] = test_uint32 */
2997
  8,   /* field[8] = test_uint64 */
2998
};
2999
static const ProtobufCIntRange foo__test_mess_optional__number_ranges[1 + 1] =
3000
{
3001
  { 1, 0 },
3002
  { 0, 18 }
3003
};
3004
const ProtobufCMessageDescriptor foo__test_mess_optional__descriptor =
3005
{
3006
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3007
  "foo.TestMessOptional",
3008
  "TestMessOptional",
3009
  "Foo__TestMessOptional",
3010
  "foo",
3011
  sizeof(Foo__TestMessOptional),
3012
  18,
3013
  foo__test_mess_optional__field_descriptors,
3014
  foo__test_mess_optional__field_indices_by_name,
3015
  1,  foo__test_mess_optional__number_ranges,
3016
  NULL, /* gen_init_helpers = false */
3017
  NULL,NULL,NULL    /* reserved[123] */
3018
};
3019
static const ProtobufCFieldDescriptor foo__test_mess_oneof__field_descriptors[19] =
3020
{
3021
  {
3022
    "test_int32",
3023
    1,
3024
    PROTOBUF_C_LABEL_OPTIONAL,
3025
    PROTOBUF_C_TYPE_INT32,
3026
    offsetof(Foo__TestMessOneof, test_oneof_case),
3027
    offsetof(Foo__TestMessOneof, test_int32),
3028
    NULL,
3029
    NULL,
3030
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3031
    0,NULL,NULL    /* reserved1,reserved2, etc */
3032
  },
3033
  {
3034
    "test_sint32",
3035
    2,
3036
    PROTOBUF_C_LABEL_OPTIONAL,
3037
    PROTOBUF_C_TYPE_SINT32,
3038
    offsetof(Foo__TestMessOneof, test_oneof_case),
3039
    offsetof(Foo__TestMessOneof, test_sint32),
3040
    NULL,
3041
    NULL,
3042
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3043
    0,NULL,NULL    /* reserved1,reserved2, etc */
3044
  },
3045
  {
3046
    "test_sfixed32",
3047
    3,
3048
    PROTOBUF_C_LABEL_OPTIONAL,
3049
    PROTOBUF_C_TYPE_SFIXED32,
3050
    offsetof(Foo__TestMessOneof, test_oneof_case),
3051
    offsetof(Foo__TestMessOneof, test_sfixed32),
3052
    NULL,
3053
    NULL,
3054
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3055
    0,NULL,NULL    /* reserved1,reserved2, etc */
3056
  },
3057
  {
3058
    "test_int64",
3059
    4,
3060
    PROTOBUF_C_LABEL_OPTIONAL,
3061
    PROTOBUF_C_TYPE_INT64,
3062
    offsetof(Foo__TestMessOneof, test_oneof_case),
3063
    offsetof(Foo__TestMessOneof, test_int64),
3064
    NULL,
3065
    NULL,
3066
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3067
    0,NULL,NULL    /* reserved1,reserved2, etc */
3068
  },
3069
  {
3070
    "test_sint64",
3071
    5,
3072
    PROTOBUF_C_LABEL_OPTIONAL,
3073
    PROTOBUF_C_TYPE_SINT64,
3074
    offsetof(Foo__TestMessOneof, test_oneof_case),
3075
    offsetof(Foo__TestMessOneof, test_sint64),
3076
    NULL,
3077
    NULL,
3078
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3079
    0,NULL,NULL    /* reserved1,reserved2, etc */
3080
  },
3081
  {
3082
    "test_sfixed64",
3083
    6,
3084
    PROTOBUF_C_LABEL_OPTIONAL,
3085
    PROTOBUF_C_TYPE_SFIXED64,
3086
    offsetof(Foo__TestMessOneof, test_oneof_case),
3087
    offsetof(Foo__TestMessOneof, test_sfixed64),
3088
    NULL,
3089
    NULL,
3090
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3091
    0,NULL,NULL    /* reserved1,reserved2, etc */
3092
  },
3093
  {
3094
    "test_uint32",
3095
    7,
3096
    PROTOBUF_C_LABEL_OPTIONAL,
3097
    PROTOBUF_C_TYPE_UINT32,
3098
    offsetof(Foo__TestMessOneof, test_oneof_case),
3099
    offsetof(Foo__TestMessOneof, test_uint32),
3100
    NULL,
3101
    NULL,
3102
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3103
    0,NULL,NULL    /* reserved1,reserved2, etc */
3104
  },
3105
  {
3106
    "test_fixed32",
3107
    8,
3108
    PROTOBUF_C_LABEL_OPTIONAL,
3109
    PROTOBUF_C_TYPE_FIXED32,
3110
    offsetof(Foo__TestMessOneof, test_oneof_case),
3111
    offsetof(Foo__TestMessOneof, test_fixed32),
3112
    NULL,
3113
    NULL,
3114
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3115
    0,NULL,NULL    /* reserved1,reserved2, etc */
3116
  },
3117
  {
3118
    "test_uint64",
3119
    9,
3120
    PROTOBUF_C_LABEL_OPTIONAL,
3121
    PROTOBUF_C_TYPE_UINT64,
3122
    offsetof(Foo__TestMessOneof, test_oneof_case),
3123
    offsetof(Foo__TestMessOneof, test_uint64),
3124
    NULL,
3125
    NULL,
3126
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3127
    0,NULL,NULL    /* reserved1,reserved2, etc */
3128
  },
3129
  {
3130
    "test_fixed64",
3131
    10,
3132
    PROTOBUF_C_LABEL_OPTIONAL,
3133
    PROTOBUF_C_TYPE_FIXED64,
3134
    offsetof(Foo__TestMessOneof, test_oneof_case),
3135
    offsetof(Foo__TestMessOneof, test_fixed64),
3136
    NULL,
3137
    NULL,
3138
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3139
    0,NULL,NULL    /* reserved1,reserved2, etc */
3140
  },
3141
  {
3142
    "test_float",
3143
    11,
3144
    PROTOBUF_C_LABEL_OPTIONAL,
3145
    PROTOBUF_C_TYPE_FLOAT,
3146
    offsetof(Foo__TestMessOneof, test_oneof_case),
3147
    offsetof(Foo__TestMessOneof, test_float),
3148
    NULL,
3149
    NULL,
3150
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3151
    0,NULL,NULL    /* reserved1,reserved2, etc */
3152
  },
3153
  {
3154
    "test_double",
3155
    12,
3156
    PROTOBUF_C_LABEL_OPTIONAL,
3157
    PROTOBUF_C_TYPE_DOUBLE,
3158
    offsetof(Foo__TestMessOneof, test_oneof_case),
3159
    offsetof(Foo__TestMessOneof, test_double),
3160
    NULL,
3161
    NULL,
3162
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3163
    0,NULL,NULL    /* reserved1,reserved2, etc */
3164
  },
3165
  {
3166
    "test_boolean",
3167
    13,
3168
    PROTOBUF_C_LABEL_OPTIONAL,
3169
    PROTOBUF_C_TYPE_BOOL,
3170
    offsetof(Foo__TestMessOneof, test_oneof_case),
3171
    offsetof(Foo__TestMessOneof, test_boolean),
3172
    NULL,
3173
    NULL,
3174
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3175
    0,NULL,NULL    /* reserved1,reserved2, etc */
3176
  },
3177
  {
3178
    "test_enum_small",
3179
    14,
3180
    PROTOBUF_C_LABEL_OPTIONAL,
3181
    PROTOBUF_C_TYPE_ENUM,
3182
    offsetof(Foo__TestMessOneof, test_oneof_case),
3183
    offsetof(Foo__TestMessOneof, test_enum_small),
3184
    &foo__test_enum_small__descriptor,
3185
    NULL,
3186
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3187
    0,NULL,NULL    /* reserved1,reserved2, etc */
3188
  },
3189
  {
3190
    "test_enum",
3191
    15,
3192
    PROTOBUF_C_LABEL_OPTIONAL,
3193
    PROTOBUF_C_TYPE_ENUM,
3194
    offsetof(Foo__TestMessOneof, test_oneof_case),
3195
    offsetof(Foo__TestMessOneof, test_enum),
3196
    &foo__test_enum__descriptor,
3197
    NULL,
3198
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3199
    0,NULL,NULL    /* reserved1,reserved2, etc */
3200
  },
3201
  {
3202
    "test_string",
3203
    16,
3204
    PROTOBUF_C_LABEL_OPTIONAL,
3205
    PROTOBUF_C_TYPE_STRING,
3206
    offsetof(Foo__TestMessOneof, test_oneof_case),
3207
    offsetof(Foo__TestMessOneof, test_string),
3208
    NULL,
3209
    NULL,
3210
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3211
    0,NULL,NULL    /* reserved1,reserved2, etc */
3212
  },
3213
  {
3214
    "test_bytes",
3215
    17,
3216
    PROTOBUF_C_LABEL_OPTIONAL,
3217
    PROTOBUF_C_TYPE_BYTES,
3218
    offsetof(Foo__TestMessOneof, test_oneof_case),
3219
    offsetof(Foo__TestMessOneof, test_bytes),
3220
    NULL,
3221
    NULL,
3222
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3223
    0,NULL,NULL    /* reserved1,reserved2, etc */
3224
  },
3225
  {
3226
    "test_message",
3227
    18,
3228
    PROTOBUF_C_LABEL_OPTIONAL,
3229
    PROTOBUF_C_TYPE_MESSAGE,
3230
    offsetof(Foo__TestMessOneof, test_oneof_case),
3231
    offsetof(Foo__TestMessOneof, test_message),
3232
    &foo__sub_mess__descriptor,
3233
    NULL,
3234
    PROTOBUF_C_FIELD_FLAG_ONEOF,             /* flags */
3235
    0,NULL,NULL    /* reserved1,reserved2, etc */
3236
  },
3237
  {
3238
    "opt_int",
3239
    19,
3240
    PROTOBUF_C_LABEL_OPTIONAL,
3241
    PROTOBUF_C_TYPE_INT32,
3242
    offsetof(Foo__TestMessOneof, has_opt_int),
3243
    offsetof(Foo__TestMessOneof, opt_int),
3244
    NULL,
3245
    NULL,
3246
    0,             /* flags */
3247
    0,NULL,NULL    /* reserved1,reserved2, etc */
3248
  },
3249
};
3250
static const unsigned foo__test_mess_oneof__field_indices_by_name[] = {
3251
  18,   /* field[18] = opt_int */
3252
  12,   /* field[12] = test_boolean */
3253
  16,   /* field[16] = test_bytes */
3254
  11,   /* field[11] = test_double */
3255
  14,   /* field[14] = test_enum */
3256
  13,   /* field[13] = test_enum_small */
3257
  7,   /* field[7] = test_fixed32 */
3258
  9,   /* field[9] = test_fixed64 */
3259
  10,   /* field[10] = test_float */
3260
  0,   /* field[0] = test_int32 */
3261
  3,   /* field[3] = test_int64 */
3262
  17,   /* field[17] = test_message */
3263
  2,   /* field[2] = test_sfixed32 */
3264
  5,   /* field[5] = test_sfixed64 */
3265
  1,   /* field[1] = test_sint32 */
3266
  4,   /* field[4] = test_sint64 */
3267
  15,   /* field[15] = test_string */
3268
  6,   /* field[6] = test_uint32 */
3269
  8,   /* field[8] = test_uint64 */
3270
};
3271
static const ProtobufCIntRange foo__test_mess_oneof__number_ranges[1 + 1] =
3272
{
3273
  { 1, 0 },
3274
  { 0, 19 }
3275
};
3276
const ProtobufCMessageDescriptor foo__test_mess_oneof__descriptor =
3277
{
3278
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3279
  "foo.TestMessOneof",
3280
  "TestMessOneof",
3281
  "Foo__TestMessOneof",
3282
  "foo",
3283
  sizeof(Foo__TestMessOneof),
3284
  19,
3285
  foo__test_mess_oneof__field_descriptors,
3286
  foo__test_mess_oneof__field_indices_by_name,
3287
  1,  foo__test_mess_oneof__number_ranges,
3288
  (ProtobufCMessageInit) foo__test_mess_oneof__init,
3289
  NULL,NULL,NULL    /* reserved[123] */
3290
};
3291
static const ProtobufCFieldDescriptor foo__test_mess_required_int32__field_descriptors[1] =
3292
{
3293
  {
3294
    "test",
3295
    42,
3296
    PROTOBUF_C_LABEL_REQUIRED,
3297
    PROTOBUF_C_TYPE_INT32,
3298
    0,   /* quantifier_offset */
3299
    offsetof(Foo__TestMessRequiredInt32, test),
3300
    NULL,
3301
    NULL,
3302
    0,             /* flags */
3303
    0,NULL,NULL    /* reserved1,reserved2, etc */
3304
  },
3305
};
3306
static const unsigned foo__test_mess_required_int32__field_indices_by_name[] = {
3307
  0,   /* field[0] = test */
3308
};
3309
static const ProtobufCIntRange foo__test_mess_required_int32__number_ranges[1 + 1] =
3310
{
3311
  { 42, 0 },
3312
  { 0, 1 }
3313
};
3314
const ProtobufCMessageDescriptor foo__test_mess_required_int32__descriptor =
3315
{
3316
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3317
  "foo.TestMessRequiredInt32",
3318
  "TestMessRequiredInt32",
3319
  "Foo__TestMessRequiredInt32",
3320
  "foo",
3321
  sizeof(Foo__TestMessRequiredInt32),
3322
  1,
3323
  foo__test_mess_required_int32__field_descriptors,
3324
  foo__test_mess_required_int32__field_indices_by_name,
3325
  1,  foo__test_mess_required_int32__number_ranges,
3326
  (ProtobufCMessageInit) foo__test_mess_required_int32__init,
3327
  NULL,NULL,NULL    /* reserved[123] */
3328
};
3329
static const ProtobufCFieldDescriptor foo__test_mess_required_sint32__field_descriptors[1] =
3330
{
3331
  {
3332
    "test",
3333
    43,
3334
    PROTOBUF_C_LABEL_REQUIRED,
3335
    PROTOBUF_C_TYPE_SINT32,
3336
    0,   /* quantifier_offset */
3337
    offsetof(Foo__TestMessRequiredSInt32, test),
3338
    NULL,
3339
    NULL,
3340
    0,             /* flags */
3341
    0,NULL,NULL    /* reserved1,reserved2, etc */
3342
  },
3343
};
3344
static const unsigned foo__test_mess_required_sint32__field_indices_by_name[] = {
3345
  0,   /* field[0] = test */
3346
};
3347
static const ProtobufCIntRange foo__test_mess_required_sint32__number_ranges[1 + 1] =
3348
{
3349
  { 43, 0 },
3350
  { 0, 1 }
3351
};
3352
const ProtobufCMessageDescriptor foo__test_mess_required_sint32__descriptor =
3353
{
3354
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3355
  "foo.TestMessRequiredSInt32",
3356
  "TestMessRequiredSInt32",
3357
  "Foo__TestMessRequiredSInt32",
3358
  "foo",
3359
  sizeof(Foo__TestMessRequiredSInt32),
3360
  1,
3361
  foo__test_mess_required_sint32__field_descriptors,
3362
  foo__test_mess_required_sint32__field_indices_by_name,
3363
  1,  foo__test_mess_required_sint32__number_ranges,
3364
  (ProtobufCMessageInit) foo__test_mess_required_sint32__init,
3365
  NULL,NULL,NULL    /* reserved[123] */
3366
};
3367
static const ProtobufCFieldDescriptor foo__test_mess_required_sfixed32__field_descriptors[1] =
3368
{
3369
  {
3370
    "test",
3371
    100,
3372
    PROTOBUF_C_LABEL_REQUIRED,
3373
    PROTOBUF_C_TYPE_SFIXED32,
3374
    0,   /* quantifier_offset */
3375
    offsetof(Foo__TestMessRequiredSFixed32, test),
3376
    NULL,
3377
    NULL,
3378
    0,             /* flags */
3379
    0,NULL,NULL    /* reserved1,reserved2, etc */
3380
  },
3381
};
3382
static const unsigned foo__test_mess_required_sfixed32__field_indices_by_name[] = {
3383
  0,   /* field[0] = test */
3384
};
3385
static const ProtobufCIntRange foo__test_mess_required_sfixed32__number_ranges[1 + 1] =
3386
{
3387
  { 100, 0 },
3388
  { 0, 1 }
3389
};
3390
const ProtobufCMessageDescriptor foo__test_mess_required_sfixed32__descriptor =
3391
{
3392
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3393
  "foo.TestMessRequiredSFixed32",
3394
  "TestMessRequiredSFixed32",
3395
  "Foo__TestMessRequiredSFixed32",
3396
  "foo",
3397
  sizeof(Foo__TestMessRequiredSFixed32),
3398
  1,
3399
  foo__test_mess_required_sfixed32__field_descriptors,
3400
  foo__test_mess_required_sfixed32__field_indices_by_name,
3401
  1,  foo__test_mess_required_sfixed32__number_ranges,
3402
  (ProtobufCMessageInit) foo__test_mess_required_sfixed32__init,
3403
  NULL,NULL,NULL    /* reserved[123] */
3404
};
3405
static const ProtobufCFieldDescriptor foo__test_mess_required_int64__field_descriptors[1] =
3406
{
3407
  {
3408
    "test",
3409
    1,
3410
    PROTOBUF_C_LABEL_REQUIRED,
3411
    PROTOBUF_C_TYPE_INT64,
3412
    0,   /* quantifier_offset */
3413
    offsetof(Foo__TestMessRequiredInt64, test),
3414
    NULL,
3415
    NULL,
3416
    0,             /* flags */
3417
    0,NULL,NULL    /* reserved1,reserved2, etc */
3418
  },
3419
};
3420
static const unsigned foo__test_mess_required_int64__field_indices_by_name[] = {
3421
  0,   /* field[0] = test */
3422
};
3423
static const ProtobufCIntRange foo__test_mess_required_int64__number_ranges[1 + 1] =
3424
{
3425
  { 1, 0 },
3426
  { 0, 1 }
3427
};
3428
const ProtobufCMessageDescriptor foo__test_mess_required_int64__descriptor =
3429
{
3430
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3431
  "foo.TestMessRequiredInt64",
3432
  "TestMessRequiredInt64",
3433
  "Foo__TestMessRequiredInt64",
3434
  "foo",
3435
  sizeof(Foo__TestMessRequiredInt64),
3436
  1,
3437
  foo__test_mess_required_int64__field_descriptors,
3438
  foo__test_mess_required_int64__field_indices_by_name,
3439
  1,  foo__test_mess_required_int64__number_ranges,
3440
  (ProtobufCMessageInit) foo__test_mess_required_int64__init,
3441
  NULL,NULL,NULL    /* reserved[123] */
3442
};
3443
static const ProtobufCFieldDescriptor foo__test_mess_required_sint64__field_descriptors[1] =
3444
{
3445
  {
3446
    "test",
3447
    11,
3448
    PROTOBUF_C_LABEL_REQUIRED,
3449
    PROTOBUF_C_TYPE_SINT64,
3450
    0,   /* quantifier_offset */
3451
    offsetof(Foo__TestMessRequiredSInt64, test),
3452
    NULL,
3453
    NULL,
3454
    0,             /* flags */
3455
    0,NULL,NULL    /* reserved1,reserved2, etc */
3456
  },
3457
};
3458
static const unsigned foo__test_mess_required_sint64__field_indices_by_name[] = {
3459
  0,   /* field[0] = test */
3460
};
3461
static const ProtobufCIntRange foo__test_mess_required_sint64__number_ranges[1 + 1] =
3462
{
3463
  { 11, 0 },
3464
  { 0, 1 }
3465
};
3466
const ProtobufCMessageDescriptor foo__test_mess_required_sint64__descriptor =
3467
{
3468
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3469
  "foo.TestMessRequiredSInt64",
3470
  "TestMessRequiredSInt64",
3471
  "Foo__TestMessRequiredSInt64",
3472
  "foo",
3473
  sizeof(Foo__TestMessRequiredSInt64),
3474
  1,
3475
  foo__test_mess_required_sint64__field_descriptors,
3476
  foo__test_mess_required_sint64__field_indices_by_name,
3477
  1,  foo__test_mess_required_sint64__number_ranges,
3478
  (ProtobufCMessageInit) foo__test_mess_required_sint64__init,
3479
  NULL,NULL,NULL    /* reserved[123] */
3480
};
3481
static const ProtobufCFieldDescriptor foo__test_mess_required_sfixed64__field_descriptors[1] =
3482
{
3483
  {
3484
    "test",
3485
    12,
3486
    PROTOBUF_C_LABEL_REQUIRED,
3487
    PROTOBUF_C_TYPE_SFIXED64,
3488
    0,   /* quantifier_offset */
3489
    offsetof(Foo__TestMessRequiredSFixed64, test),
3490
    NULL,
3491
    NULL,
3492
    0,             /* flags */
3493
    0,NULL,NULL    /* reserved1,reserved2, etc */
3494
  },
3495
};
3496
static const unsigned foo__test_mess_required_sfixed64__field_indices_by_name[] = {
3497
  0,   /* field[0] = test */
3498
};
3499
static const ProtobufCIntRange foo__test_mess_required_sfixed64__number_ranges[1 + 1] =
3500
{
3501
  { 12, 0 },
3502
  { 0, 1 }
3503
};
3504
const ProtobufCMessageDescriptor foo__test_mess_required_sfixed64__descriptor =
3505
{
3506
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3507
  "foo.TestMessRequiredSFixed64",
3508
  "TestMessRequiredSFixed64",
3509
  "Foo__TestMessRequiredSFixed64",
3510
  "foo",
3511
  sizeof(Foo__TestMessRequiredSFixed64),
3512
  1,
3513
  foo__test_mess_required_sfixed64__field_descriptors,
3514
  foo__test_mess_required_sfixed64__field_indices_by_name,
3515
  1,  foo__test_mess_required_sfixed64__number_ranges,
3516
  (ProtobufCMessageInit) foo__test_mess_required_sfixed64__init,
3517
  NULL,NULL,NULL    /* reserved[123] */
3518
};
3519
static const ProtobufCFieldDescriptor foo__test_mess_required_uint32__field_descriptors[1] =
3520
{
3521
  {
3522
    "test",
3523
    1,
3524
    PROTOBUF_C_LABEL_REQUIRED,
3525
    PROTOBUF_C_TYPE_UINT32,
3526
    0,   /* quantifier_offset */
3527
    offsetof(Foo__TestMessRequiredUInt32, test),
3528
    NULL,
3529
    NULL,
3530
    0,             /* flags */
3531
    0,NULL,NULL    /* reserved1,reserved2, etc */
3532
  },
3533
};
3534
static const unsigned foo__test_mess_required_uint32__field_indices_by_name[] = {
3535
  0,   /* field[0] = test */
3536
};
3537
static const ProtobufCIntRange foo__test_mess_required_uint32__number_ranges[1 + 1] =
3538
{
3539
  { 1, 0 },
3540
  { 0, 1 }
3541
};
3542
const ProtobufCMessageDescriptor foo__test_mess_required_uint32__descriptor =
3543
{
3544
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3545
  "foo.TestMessRequiredUInt32",
3546
  "TestMessRequiredUInt32",
3547
  "Foo__TestMessRequiredUInt32",
3548
  "foo",
3549
  sizeof(Foo__TestMessRequiredUInt32),
3550
  1,
3551
  foo__test_mess_required_uint32__field_descriptors,
3552
  foo__test_mess_required_uint32__field_indices_by_name,
3553
  1,  foo__test_mess_required_uint32__number_ranges,
3554
  (ProtobufCMessageInit) foo__test_mess_required_uint32__init,
3555
  NULL,NULL,NULL    /* reserved[123] */
3556
};
3557
static const ProtobufCFieldDescriptor foo__test_mess_required_fixed32__field_descriptors[1] =
3558
{
3559
  {
3560
    "test",
3561
    1,
3562
    PROTOBUF_C_LABEL_REQUIRED,
3563
    PROTOBUF_C_TYPE_FIXED32,
3564
    0,   /* quantifier_offset */
3565
    offsetof(Foo__TestMessRequiredFixed32, test),
3566
    NULL,
3567
    NULL,
3568
    0,             /* flags */
3569
    0,NULL,NULL    /* reserved1,reserved2, etc */
3570
  },
3571
};
3572
static const unsigned foo__test_mess_required_fixed32__field_indices_by_name[] = {
3573
  0,   /* field[0] = test */
3574
};
3575
static const ProtobufCIntRange foo__test_mess_required_fixed32__number_ranges[1 + 1] =
3576
{
3577
  { 1, 0 },
3578
  { 0, 1 }
3579
};
3580
const ProtobufCMessageDescriptor foo__test_mess_required_fixed32__descriptor =
3581
{
3582
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3583
  "foo.TestMessRequiredFixed32",
3584
  "TestMessRequiredFixed32",
3585
  "Foo__TestMessRequiredFixed32",
3586
  "foo",
3587
  sizeof(Foo__TestMessRequiredFixed32),
3588
  1,
3589
  foo__test_mess_required_fixed32__field_descriptors,
3590
  foo__test_mess_required_fixed32__field_indices_by_name,
3591
  1,  foo__test_mess_required_fixed32__number_ranges,
3592
  (ProtobufCMessageInit) foo__test_mess_required_fixed32__init,
3593
  NULL,NULL,NULL    /* reserved[123] */
3594
};
3595
static const ProtobufCFieldDescriptor foo__test_mess_required_uint64__field_descriptors[1] =
3596
{
3597
  {
3598
    "test",
3599
    1,
3600
    PROTOBUF_C_LABEL_REQUIRED,
3601
    PROTOBUF_C_TYPE_UINT64,
3602
    0,   /* quantifier_offset */
3603
    offsetof(Foo__TestMessRequiredUInt64, test),
3604
    NULL,
3605
    NULL,
3606
    0,             /* flags */
3607
    0,NULL,NULL    /* reserved1,reserved2, etc */
3608
  },
3609
};
3610
static const unsigned foo__test_mess_required_uint64__field_indices_by_name[] = {
3611
  0,   /* field[0] = test */
3612
};
3613
static const ProtobufCIntRange foo__test_mess_required_uint64__number_ranges[1 + 1] =
3614
{
3615
  { 1, 0 },
3616
  { 0, 1 }
3617
};
3618
const ProtobufCMessageDescriptor foo__test_mess_required_uint64__descriptor =
3619
{
3620
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3621
  "foo.TestMessRequiredUInt64",
3622
  "TestMessRequiredUInt64",
3623
  "Foo__TestMessRequiredUInt64",
3624
  "foo",
3625
  sizeof(Foo__TestMessRequiredUInt64),
3626
  1,
3627
  foo__test_mess_required_uint64__field_descriptors,
3628
  foo__test_mess_required_uint64__field_indices_by_name,
3629
  1,  foo__test_mess_required_uint64__number_ranges,
3630
  (ProtobufCMessageInit) foo__test_mess_required_uint64__init,
3631
  NULL,NULL,NULL    /* reserved[123] */
3632
};
3633
static const ProtobufCFieldDescriptor foo__test_mess_required_fixed64__field_descriptors[1] =
3634
{
3635
  {
3636
    "test",
3637
    1,
3638
    PROTOBUF_C_LABEL_REQUIRED,
3639
    PROTOBUF_C_TYPE_FIXED64,
3640
    0,   /* quantifier_offset */
3641
    offsetof(Foo__TestMessRequiredFixed64, test),
3642
    NULL,
3643
    NULL,
3644
    0,             /* flags */
3645
    0,NULL,NULL    /* reserved1,reserved2, etc */
3646
  },
3647
};
3648
static const unsigned foo__test_mess_required_fixed64__field_indices_by_name[] = {
3649
  0,   /* field[0] = test */
3650
};
3651
static const ProtobufCIntRange foo__test_mess_required_fixed64__number_ranges[1 + 1] =
3652
{
3653
  { 1, 0 },
3654
  { 0, 1 }
3655
};
3656
const ProtobufCMessageDescriptor foo__test_mess_required_fixed64__descriptor =
3657
{
3658
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3659
  "foo.TestMessRequiredFixed64",
3660
  "TestMessRequiredFixed64",
3661
  "Foo__TestMessRequiredFixed64",
3662
  "foo",
3663
  sizeof(Foo__TestMessRequiredFixed64),
3664
  1,
3665
  foo__test_mess_required_fixed64__field_descriptors,
3666
  foo__test_mess_required_fixed64__field_indices_by_name,
3667
  1,  foo__test_mess_required_fixed64__number_ranges,
3668
  (ProtobufCMessageInit) foo__test_mess_required_fixed64__init,
3669
  NULL,NULL,NULL    /* reserved[123] */
3670
};
3671
static const ProtobufCFieldDescriptor foo__test_mess_required_float__field_descriptors[1] =
3672
{
3673
  {
3674
    "test",
3675
    1,
3676
    PROTOBUF_C_LABEL_REQUIRED,
3677
    PROTOBUF_C_TYPE_FLOAT,
3678
    0,   /* quantifier_offset */
3679
    offsetof(Foo__TestMessRequiredFloat, test),
3680
    NULL,
3681
    NULL,
3682
    0,             /* flags */
3683
    0,NULL,NULL    /* reserved1,reserved2, etc */
3684
  },
3685
};
3686
static const unsigned foo__test_mess_required_float__field_indices_by_name[] = {
3687
  0,   /* field[0] = test */
3688
};
3689
static const ProtobufCIntRange foo__test_mess_required_float__number_ranges[1 + 1] =
3690
{
3691
  { 1, 0 },
3692
  { 0, 1 }
3693
};
3694
const ProtobufCMessageDescriptor foo__test_mess_required_float__descriptor =
3695
{
3696
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3697
  "foo.TestMessRequiredFloat",
3698
  "TestMessRequiredFloat",
3699
  "Foo__TestMessRequiredFloat",
3700
  "foo",
3701
  sizeof(Foo__TestMessRequiredFloat),
3702
  1,
3703
  foo__test_mess_required_float__field_descriptors,
3704
  foo__test_mess_required_float__field_indices_by_name,
3705
  1,  foo__test_mess_required_float__number_ranges,
3706
  (ProtobufCMessageInit) foo__test_mess_required_float__init,
3707
  NULL,NULL,NULL    /* reserved[123] */
3708
};
3709
static const ProtobufCFieldDescriptor foo__test_mess_required_double__field_descriptors[1] =
3710
{
3711
  {
3712
    "test",
3713
    1,
3714
    PROTOBUF_C_LABEL_REQUIRED,
3715
    PROTOBUF_C_TYPE_DOUBLE,
3716
    0,   /* quantifier_offset */
3717
    offsetof(Foo__TestMessRequiredDouble, test),
3718
    NULL,
3719
    NULL,
3720
    0,             /* flags */
3721
    0,NULL,NULL    /* reserved1,reserved2, etc */
3722
  },
3723
};
3724
static const unsigned foo__test_mess_required_double__field_indices_by_name[] = {
3725
  0,   /* field[0] = test */
3726
};
3727
static const ProtobufCIntRange foo__test_mess_required_double__number_ranges[1 + 1] =
3728
{
3729
  { 1, 0 },
3730
  { 0, 1 }
3731
};
3732
const ProtobufCMessageDescriptor foo__test_mess_required_double__descriptor =
3733
{
3734
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3735
  "foo.TestMessRequiredDouble",
3736
  "TestMessRequiredDouble",
3737
  "Foo__TestMessRequiredDouble",
3738
  "foo",
3739
  sizeof(Foo__TestMessRequiredDouble),
3740
  1,
3741
  foo__test_mess_required_double__field_descriptors,
3742
  foo__test_mess_required_double__field_indices_by_name,
3743
  1,  foo__test_mess_required_double__number_ranges,
3744
  (ProtobufCMessageInit) foo__test_mess_required_double__init,
3745
  NULL,NULL,NULL    /* reserved[123] */
3746
};
3747
static const ProtobufCFieldDescriptor foo__test_mess_required_bool__field_descriptors[1] =
3748
{
3749
  {
3750
    "test",
3751
    1,
3752
    PROTOBUF_C_LABEL_REQUIRED,
3753
    PROTOBUF_C_TYPE_BOOL,
3754
    0,   /* quantifier_offset */
3755
    offsetof(Foo__TestMessRequiredBool, test),
3756
    NULL,
3757
    NULL,
3758
    0,             /* flags */
3759
    0,NULL,NULL    /* reserved1,reserved2, etc */
3760
  },
3761
};
3762
static const unsigned foo__test_mess_required_bool__field_indices_by_name[] = {
3763
  0,   /* field[0] = test */
3764
};
3765
static const ProtobufCIntRange foo__test_mess_required_bool__number_ranges[1 + 1] =
3766
{
3767
  { 1, 0 },
3768
  { 0, 1 }
3769
};
3770
const ProtobufCMessageDescriptor foo__test_mess_required_bool__descriptor =
3771
{
3772
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3773
  "foo.TestMessRequiredBool",
3774
  "TestMessRequiredBool",
3775
  "Foo__TestMessRequiredBool",
3776
  "foo",
3777
  sizeof(Foo__TestMessRequiredBool),
3778
  1,
3779
  foo__test_mess_required_bool__field_descriptors,
3780
  foo__test_mess_required_bool__field_indices_by_name,
3781
  1,  foo__test_mess_required_bool__number_ranges,
3782
  (ProtobufCMessageInit) foo__test_mess_required_bool__init,
3783
  NULL,NULL,NULL    /* reserved[123] */
3784
};
3785
static const ProtobufCFieldDescriptor foo__test_mess_required_enum__field_descriptors[1] =
3786
{
3787
  {
3788
    "test",
3789
    1,
3790
    PROTOBUF_C_LABEL_REQUIRED,
3791
    PROTOBUF_C_TYPE_ENUM,
3792
    0,   /* quantifier_offset */
3793
    offsetof(Foo__TestMessRequiredEnum, test),
3794
    &foo__test_enum__descriptor,
3795
    NULL,
3796
    0,             /* flags */
3797
    0,NULL,NULL    /* reserved1,reserved2, etc */
3798
  },
3799
};
3800
static const unsigned foo__test_mess_required_enum__field_indices_by_name[] = {
3801
  0,   /* field[0] = test */
3802
};
3803
static const ProtobufCIntRange foo__test_mess_required_enum__number_ranges[1 + 1] =
3804
{
3805
  { 1, 0 },
3806
  { 0, 1 }
3807
};
3808
const ProtobufCMessageDescriptor foo__test_mess_required_enum__descriptor =
3809
{
3810
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3811
  "foo.TestMessRequiredEnum",
3812
  "TestMessRequiredEnum",
3813
  "Foo__TestMessRequiredEnum",
3814
  "foo",
3815
  sizeof(Foo__TestMessRequiredEnum),
3816
  1,
3817
  foo__test_mess_required_enum__field_descriptors,
3818
  foo__test_mess_required_enum__field_indices_by_name,
3819
  1,  foo__test_mess_required_enum__number_ranges,
3820
  (ProtobufCMessageInit) foo__test_mess_required_enum__init,
3821
  NULL,NULL,NULL    /* reserved[123] */
3822
};
3823
static const ProtobufCFieldDescriptor foo__test_mess_required_enum_small__field_descriptors[1] =
3824
{
3825
  {
3826
    "test",
3827
    1,
3828
    PROTOBUF_C_LABEL_REQUIRED,
3829
    PROTOBUF_C_TYPE_ENUM,
3830
    0,   /* quantifier_offset */
3831
    offsetof(Foo__TestMessRequiredEnumSmall, test),
3832
    &foo__test_enum_small__descriptor,
3833
    NULL,
3834
    0,             /* flags */
3835
    0,NULL,NULL    /* reserved1,reserved2, etc */
3836
  },
3837
};
3838
static const unsigned foo__test_mess_required_enum_small__field_indices_by_name[] = {
3839
  0,   /* field[0] = test */
3840
};
3841
static const ProtobufCIntRange foo__test_mess_required_enum_small__number_ranges[1 + 1] =
3842
{
3843
  { 1, 0 },
3844
  { 0, 1 }
3845
};
3846
const ProtobufCMessageDescriptor foo__test_mess_required_enum_small__descriptor =
3847
{
3848
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3849
  "foo.TestMessRequiredEnumSmall",
3850
  "TestMessRequiredEnumSmall",
3851
  "Foo__TestMessRequiredEnumSmall",
3852
  "foo",
3853
  sizeof(Foo__TestMessRequiredEnumSmall),
3854
  1,
3855
  foo__test_mess_required_enum_small__field_descriptors,
3856
  foo__test_mess_required_enum_small__field_indices_by_name,
3857
  1,  foo__test_mess_required_enum_small__number_ranges,
3858
  (ProtobufCMessageInit) foo__test_mess_required_enum_small__init,
3859
  NULL,NULL,NULL    /* reserved[123] */
3860
};
3861
static const ProtobufCFieldDescriptor foo__test_mess_required_string__field_descriptors[1] =
3862
{
3863
  {
3864
    "test",
3865
    1,
3866
    PROTOBUF_C_LABEL_REQUIRED,
3867
    PROTOBUF_C_TYPE_STRING,
3868
    0,   /* quantifier_offset */
3869
    offsetof(Foo__TestMessRequiredString, test),
3870
    NULL,
3871
    NULL,
3872
    0,             /* flags */
3873
    0,NULL,NULL    /* reserved1,reserved2, etc */
3874
  },
3875
};
3876
static const unsigned foo__test_mess_required_string__field_indices_by_name[] = {
3877
  0,   /* field[0] = test */
3878
};
3879
static const ProtobufCIntRange foo__test_mess_required_string__number_ranges[1 + 1] =
3880
{
3881
  { 1, 0 },
3882
  { 0, 1 }
3883
};
3884
const ProtobufCMessageDescriptor foo__test_mess_required_string__descriptor =
3885
{
3886
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3887
  "foo.TestMessRequiredString",
3888
  "TestMessRequiredString",
3889
  "Foo__TestMessRequiredString",
3890
  "foo",
3891
  sizeof(Foo__TestMessRequiredString),
3892
  1,
3893
  foo__test_mess_required_string__field_descriptors,
3894
  foo__test_mess_required_string__field_indices_by_name,
3895
  1,  foo__test_mess_required_string__number_ranges,
3896
  (ProtobufCMessageInit) foo__test_mess_required_string__init,
3897
  NULL,NULL,NULL    /* reserved[123] */
3898
};
3899
static const ProtobufCFieldDescriptor foo__test_mess_required_bytes__field_descriptors[1] =
3900
{
3901
  {
3902
    "test",
3903
    1,
3904
    PROTOBUF_C_LABEL_REQUIRED,
3905
    PROTOBUF_C_TYPE_BYTES,
3906
    0,   /* quantifier_offset */
3907
    offsetof(Foo__TestMessRequiredBytes, test),
3908
    NULL,
3909
    NULL,
3910
    0,             /* flags */
3911
    0,NULL,NULL    /* reserved1,reserved2, etc */
3912
  },
3913
};
3914
static const unsigned foo__test_mess_required_bytes__field_indices_by_name[] = {
3915
  0,   /* field[0] = test */
3916
};
3917
static const ProtobufCIntRange foo__test_mess_required_bytes__number_ranges[1 + 1] =
3918
{
3919
  { 1, 0 },
3920
  { 0, 1 }
3921
};
3922
const ProtobufCMessageDescriptor foo__test_mess_required_bytes__descriptor =
3923
{
3924
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3925
  "foo.TestMessRequiredBytes",
3926
  "TestMessRequiredBytes",
3927
  "Foo__TestMessRequiredBytes",
3928
  "foo",
3929
  sizeof(Foo__TestMessRequiredBytes),
3930
  1,
3931
  foo__test_mess_required_bytes__field_descriptors,
3932
  foo__test_mess_required_bytes__field_indices_by_name,
3933
  1,  foo__test_mess_required_bytes__number_ranges,
3934
  (ProtobufCMessageInit) foo__test_mess_required_bytes__init,
3935
  NULL,NULL,NULL    /* reserved[123] */
3936
};
3937
static const ProtobufCFieldDescriptor foo__test_mess_required_message__field_descriptors[1] =
3938
{
3939
  {
3940
    "test",
3941
    1,
3942
    PROTOBUF_C_LABEL_REQUIRED,
3943
    PROTOBUF_C_TYPE_MESSAGE,
3944
    0,   /* quantifier_offset */
3945
    offsetof(Foo__TestMessRequiredMessage, test),
3946
    &foo__sub_mess__descriptor,
3947
    NULL,
3948
    0,             /* flags */
3949
    0,NULL,NULL    /* reserved1,reserved2, etc */
3950
  },
3951
};
3952
static const unsigned foo__test_mess_required_message__field_indices_by_name[] = {
3953
  0,   /* field[0] = test */
3954
};
3955
static const ProtobufCIntRange foo__test_mess_required_message__number_ranges[1 + 1] =
3956
{
3957
  { 1, 0 },
3958
  { 0, 1 }
3959
};
3960
const ProtobufCMessageDescriptor foo__test_mess_required_message__descriptor =
3961
{
3962
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3963
  "foo.TestMessRequiredMessage",
3964
  "TestMessRequiredMessage",
3965
  "Foo__TestMessRequiredMessage",
3966
  "foo",
3967
  sizeof(Foo__TestMessRequiredMessage),
3968
  1,
3969
  foo__test_mess_required_message__field_descriptors,
3970
  foo__test_mess_required_message__field_indices_by_name,
3971
  1,  foo__test_mess_required_message__number_ranges,
3972
  (ProtobufCMessageInit) foo__test_mess_required_message__init,
3973
  NULL,NULL,NULL    /* reserved[123] */
3974
};
3975
#define foo__empty_mess__field_descriptors NULL
3976
#define foo__empty_mess__field_indices_by_name NULL
3977
#define foo__empty_mess__number_ranges NULL
3978
const ProtobufCMessageDescriptor foo__empty_mess__descriptor =
3979
{
3980
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3981
  "foo.EmptyMess",
3982
  "EmptyMess",
3983
  "Foo__EmptyMess",
3984
  "foo",
3985
  sizeof(Foo__EmptyMess),
3986
  0,
3987
  foo__empty_mess__field_descriptors,
3988
  foo__empty_mess__field_indices_by_name,
3989
  0,  foo__empty_mess__number_ranges,
3990
  (ProtobufCMessageInit) foo__empty_mess__init,
3991
  NULL,NULL,NULL    /* reserved[123] */
3992
};
3993
char foo__default_required_values__v_string__default_value[] = "hi mom\n";
3994
uint8_t foo__default_required_values__v_bytes__default_value_data[] = "a \000 character";
3995
static const int32_t foo__default_required_values__v_int32__default_value = -42;
3996
static const uint32_t foo__default_required_values__v_uint32__default_value = 666u;
3997
static const int32_t foo__default_required_values__v_int64__default_value = 100000;
3998
static const uint32_t foo__default_required_values__v_uint64__default_value = 100001u;
3999
static const float foo__default_required_values__v_float__default_value = 2.5;
4000
static const double foo__default_required_values__v_double__default_value = 4.5;
4001
static const ProtobufCBinaryData foo__default_required_values__v_bytes__default_value = { 13, foo__default_required_values__v_bytes__default_value_data };
4002
static const ProtobufCFieldDescriptor foo__default_required_values__field_descriptors[8] =
4003
{
4004
  {
4005
    "v_int32",
4006
    1,
4007
    PROTOBUF_C_LABEL_REQUIRED,
4008
    PROTOBUF_C_TYPE_INT32,
4009
    0,   /* quantifier_offset */
4010
    offsetof(Foo__DefaultRequiredValues, v_int32),
4011
    NULL,
4012
    &foo__default_required_values__v_int32__default_value,
4013
    0,             /* flags */
4014
    0,NULL,NULL    /* reserved1,reserved2, etc */
4015
  },
4016
  {
4017
    "v_uint32",
4018
    2,
4019
    PROTOBUF_C_LABEL_REQUIRED,
4020
    PROTOBUF_C_TYPE_UINT32,
4021
    0,   /* quantifier_offset */
4022
    offsetof(Foo__DefaultRequiredValues, v_uint32),
4023
    NULL,
4024
    &foo__default_required_values__v_uint32__default_value,
4025
    0,             /* flags */
4026
    0,NULL,NULL    /* reserved1,reserved2, etc */
4027
  },
4028
  {
4029
    "v_int64",
4030
    3,
4031
    PROTOBUF_C_LABEL_REQUIRED,
4032
    PROTOBUF_C_TYPE_INT32,
4033
    0,   /* quantifier_offset */
4034
    offsetof(Foo__DefaultRequiredValues, v_int64),
4035
    NULL,
4036
    &foo__default_required_values__v_int64__default_value,
4037
    0,             /* flags */
4038
    0,NULL,NULL    /* reserved1,reserved2, etc */
4039
  },
4040
  {
4041
    "v_uint64",
4042
    4,
4043
    PROTOBUF_C_LABEL_REQUIRED,
4044
    PROTOBUF_C_TYPE_UINT32,
4045
    0,   /* quantifier_offset */
4046
    offsetof(Foo__DefaultRequiredValues, v_uint64),
4047
    NULL,
4048
    &foo__default_required_values__v_uint64__default_value,
4049
    0,             /* flags */
4050
    0,NULL,NULL    /* reserved1,reserved2, etc */
4051
  },
4052
  {
4053
    "v_float",
4054
    5,
4055
    PROTOBUF_C_LABEL_REQUIRED,
4056
    PROTOBUF_C_TYPE_FLOAT,
4057
    0,   /* quantifier_offset */
4058
    offsetof(Foo__DefaultRequiredValues, v_float),
4059
    NULL,
4060
    &foo__default_required_values__v_float__default_value,
4061
    0,             /* flags */
4062
    0,NULL,NULL    /* reserved1,reserved2, etc */
4063
  },
4064
  {
4065
    "v_double",
4066
    6,
4067
    PROTOBUF_C_LABEL_REQUIRED,
4068
    PROTOBUF_C_TYPE_DOUBLE,
4069
    0,   /* quantifier_offset */
4070
    offsetof(Foo__DefaultRequiredValues, v_double),
4071
    NULL,
4072
    &foo__default_required_values__v_double__default_value,
4073
    0,             /* flags */
4074
    0,NULL,NULL    /* reserved1,reserved2, etc */
4075
  },
4076
  {
4077
    "v_string",
4078
    7,
4079
    PROTOBUF_C_LABEL_REQUIRED,
4080
    PROTOBUF_C_TYPE_STRING,
4081
    0,   /* quantifier_offset */
4082
    offsetof(Foo__DefaultRequiredValues, v_string),
4083
    NULL,
4084
    &foo__default_required_values__v_string__default_value,
4085
    0,             /* flags */
4086
    0,NULL,NULL    /* reserved1,reserved2, etc */
4087
  },
4088
  {
4089
    "v_bytes",
4090
    8,
4091
    PROTOBUF_C_LABEL_REQUIRED,
4092
    PROTOBUF_C_TYPE_BYTES,
4093
    0,   /* quantifier_offset */
4094
    offsetof(Foo__DefaultRequiredValues, v_bytes),
4095
    NULL,
4096
    &foo__default_required_values__v_bytes__default_value,
4097
    0,             /* flags */
4098
    0,NULL,NULL    /* reserved1,reserved2, etc */
4099
  },
4100
};
4101
static const unsigned foo__default_required_values__field_indices_by_name[] = {
4102
  7,   /* field[7] = v_bytes */
4103
  5,   /* field[5] = v_double */
4104
  4,   /* field[4] = v_float */
4105
  0,   /* field[0] = v_int32 */
4106
  2,   /* field[2] = v_int64 */
4107
  6,   /* field[6] = v_string */
4108
  1,   /* field[1] = v_uint32 */
4109
  3,   /* field[3] = v_uint64 */
4110
};
4111
static const ProtobufCIntRange foo__default_required_values__number_ranges[1 + 1] =
4112
{
4113
  { 1, 0 },
4114
  { 0, 8 }
4115
};
4116
const ProtobufCMessageDescriptor foo__default_required_values__descriptor =
4117
{
4118
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4119
  "foo.DefaultRequiredValues",
4120
  "DefaultRequiredValues",
4121
  "Foo__DefaultRequiredValues",
4122
  "foo",
4123
  sizeof(Foo__DefaultRequiredValues),
4124
  8,
4125
  foo__default_required_values__field_descriptors,
4126
  foo__default_required_values__field_indices_by_name,
4127
  1,  foo__default_required_values__number_ranges,
4128
  (ProtobufCMessageInit) foo__default_required_values__init,
4129
  NULL,NULL,NULL    /* reserved[123] */
4130
};
4131
char foo__default_optional_values__v_string__default_value[] = "hi mom\n";
4132
uint8_t foo__default_optional_values__v_bytes__default_value_data[] = "a \000 character";
4133
static const int32_t foo__default_optional_values__v_int32__default_value = -42;
4134
static const uint32_t foo__default_optional_values__v_uint32__default_value = 666u;
4135
static const int32_t foo__default_optional_values__v_int64__default_value = 100000;
4136
static const uint32_t foo__default_optional_values__v_uint64__default_value = 100001u;
4137
static const float foo__default_optional_values__v_float__default_value = 2.5;
4138
static const double foo__default_optional_values__v_double__default_value = 4.5;
4139
static const ProtobufCBinaryData foo__default_optional_values__v_bytes__default_value = { 13, foo__default_optional_values__v_bytes__default_value_data };
4140
static const ProtobufCFieldDescriptor foo__default_optional_values__field_descriptors[8] =
4141
{
4142
  {
4143
    "v_int32",
4144
    1,
4145
    PROTOBUF_C_LABEL_OPTIONAL,
4146
    PROTOBUF_C_TYPE_INT32,
4147
    offsetof(Foo__DefaultOptionalValues, has_v_int32),
4148
    offsetof(Foo__DefaultOptionalValues, v_int32),
4149
    NULL,
4150
    &foo__default_optional_values__v_int32__default_value,
4151
    0,             /* flags */
4152
    0,NULL,NULL    /* reserved1,reserved2, etc */
4153
  },
4154
  {
4155
    "v_uint32",
4156
    2,
4157
    PROTOBUF_C_LABEL_OPTIONAL,
4158
    PROTOBUF_C_TYPE_UINT32,
4159
    offsetof(Foo__DefaultOptionalValues, has_v_uint32),
4160
    offsetof(Foo__DefaultOptionalValues, v_uint32),
4161
    NULL,
4162
    &foo__default_optional_values__v_uint32__default_value,
4163
    0,             /* flags */
4164
    0,NULL,NULL    /* reserved1,reserved2, etc */
4165
  },
4166
  {
4167
    "v_int64",
4168
    3,
4169
    PROTOBUF_C_LABEL_OPTIONAL,
4170
    PROTOBUF_C_TYPE_INT32,
4171
    offsetof(Foo__DefaultOptionalValues, has_v_int64),
4172
    offsetof(Foo__DefaultOptionalValues, v_int64),
4173
    NULL,
4174
    &foo__default_optional_values__v_int64__default_value,
4175
    0,             /* flags */
4176
    0,NULL,NULL    /* reserved1,reserved2, etc */
4177
  },
4178
  {
4179
    "v_uint64",
4180
    4,
4181
    PROTOBUF_C_LABEL_OPTIONAL,
4182
    PROTOBUF_C_TYPE_UINT32,
4183
    offsetof(Foo__DefaultOptionalValues, has_v_uint64),
4184
    offsetof(Foo__DefaultOptionalValues, v_uint64),
4185
    NULL,
4186
    &foo__default_optional_values__v_uint64__default_value,
4187
    0,             /* flags */
4188
    0,NULL,NULL    /* reserved1,reserved2, etc */
4189
  },
4190
  {
4191
    "v_float",
4192
    5,
4193
    PROTOBUF_C_LABEL_OPTIONAL,
4194
    PROTOBUF_C_TYPE_FLOAT,
4195
    offsetof(Foo__DefaultOptionalValues, has_v_float),
4196
    offsetof(Foo__DefaultOptionalValues, v_float),
4197
    NULL,
4198
    &foo__default_optional_values__v_float__default_value,
4199
    0,             /* flags */
4200
    0,NULL,NULL    /* reserved1,reserved2, etc */
4201
  },
4202
  {
4203
    "v_double",
4204
    6,
4205
    PROTOBUF_C_LABEL_OPTIONAL,
4206
    PROTOBUF_C_TYPE_DOUBLE,
4207
    offsetof(Foo__DefaultOptionalValues, has_v_double),
4208
    offsetof(Foo__DefaultOptionalValues, v_double),
4209
    NULL,
4210
    &foo__default_optional_values__v_double__default_value,
4211
    0,             /* flags */
4212
    0,NULL,NULL    /* reserved1,reserved2, etc */
4213
  },
4214
  {
4215
    "v_string",
4216
    7,
4217
    PROTOBUF_C_LABEL_OPTIONAL,
4218
    PROTOBUF_C_TYPE_STRING,
4219
    0,   /* quantifier_offset */
4220
    offsetof(Foo__DefaultOptionalValues, v_string),
4221
    NULL,
4222
    &foo__default_optional_values__v_string__default_value,
4223
    0,             /* flags */
4224
    0,NULL,NULL    /* reserved1,reserved2, etc */
4225
  },
4226
  {
4227
    "v_bytes",
4228
    8,
4229
    PROTOBUF_C_LABEL_OPTIONAL,
4230
    PROTOBUF_C_TYPE_BYTES,
4231
    offsetof(Foo__DefaultOptionalValues, has_v_bytes),
4232
    offsetof(Foo__DefaultOptionalValues, v_bytes),
4233
    NULL,
4234
    &foo__default_optional_values__v_bytes__default_value,
4235
    0,             /* flags */
4236
    0,NULL,NULL    /* reserved1,reserved2, etc */
4237
  },
4238
};
4239
static const unsigned foo__default_optional_values__field_indices_by_name[] = {
4240
  7,   /* field[7] = v_bytes */
4241
  5,   /* field[5] = v_double */
4242
  4,   /* field[4] = v_float */
4243
  0,   /* field[0] = v_int32 */
4244
  2,   /* field[2] = v_int64 */
4245
  6,   /* field[6] = v_string */
4246
  1,   /* field[1] = v_uint32 */
4247
  3,   /* field[3] = v_uint64 */
4248
};
4249
static const ProtobufCIntRange foo__default_optional_values__number_ranges[1 + 1] =
4250
{
4251
  { 1, 0 },
4252
  { 0, 8 }
4253
};
4254
const ProtobufCMessageDescriptor foo__default_optional_values__descriptor =
4255
{
4256
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4257
  "foo.DefaultOptionalValues",
4258
  "DefaultOptionalValues",
4259
  "Foo__DefaultOptionalValues",
4260
  "foo",
4261
  sizeof(Foo__DefaultOptionalValues),
4262
  8,
4263
  foo__default_optional_values__field_descriptors,
4264
  foo__default_optional_values__field_indices_by_name,
4265
  1,  foo__default_optional_values__number_ranges,
4266
  (ProtobufCMessageInit) foo__default_optional_values__init,
4267
  NULL,NULL,NULL    /* reserved[123] */
4268
};
4269
static const ProtobufCEnumValue foo__lower_case__case_enum__enum_values_by_number[2] =
4270
{
4271
  { "UPPER", "FOO__LOWER_CASE__CASE_ENUM__UPPER", 1 },
4272
  { "lower", "FOO__LOWER_CASE__CASE_ENUM__lower", 2 },
4273
};
4274
static const ProtobufCIntRange foo__lower_case__case_enum__value_ranges[] = {
4275
{1, 0},{0, 2}
4276
};
4277
static const ProtobufCEnumValueIndex foo__lower_case__case_enum__enum_values_by_name[2] =
4278
{
4279
  { "UPPER", 0 },
4280
  { "lower", 1 },
4281
};
4282
const ProtobufCEnumDescriptor foo__lower_case__case_enum__descriptor =
4283
{
4284
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
4285
  "foo.LowerCase.CaseEnum",
4286
  "CaseEnum",
4287
  "Foo__LowerCase__CaseEnum",
4288
  "foo",
4289
  2,
4290
  foo__lower_case__case_enum__enum_values_by_number,
4291
  2,
4292
  foo__lower_case__case_enum__enum_values_by_name,
4293
  1,
4294
  foo__lower_case__case_enum__value_ranges,
4295
  NULL,NULL,NULL,NULL   /* reserved[1234] */
4296
};
4297
static const Foo__LowerCase__CaseEnum foo__lower_case__value__default_value = FOO__LOWER_CASE__CASE_ENUM__lower;
4298
static const ProtobufCFieldDescriptor foo__lower_case__field_descriptors[1] =
4299
{
4300
  {
4301
    "value",
4302
    1,
4303
    PROTOBUF_C_LABEL_OPTIONAL,
4304
    PROTOBUF_C_TYPE_ENUM,
4305
    offsetof(Foo__LowerCase, has_value),
4306
    offsetof(Foo__LowerCase, value),
4307
    &foo__lower_case__case_enum__descriptor,
4308
    &foo__lower_case__value__default_value,
4309
    0,             /* flags */
4310
    0,NULL,NULL    /* reserved1,reserved2, etc */
4311
  },
4312
};
4313
static const unsigned foo__lower_case__field_indices_by_name[] = {
4314
  0,   /* field[0] = value */
4315
};
4316
static const ProtobufCIntRange foo__lower_case__number_ranges[1 + 1] =
4317
{
4318
  { 1, 0 },
4319
  { 0, 1 }
4320
};
4321
const ProtobufCMessageDescriptor foo__lower_case__descriptor =
4322
{
4323
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4324
  "foo.LowerCase",
4325
  "LowerCase",
4326
  "Foo__LowerCase",
4327
  "foo",
4328
  sizeof(Foo__LowerCase),
4329
  1,
4330
  foo__lower_case__field_descriptors,
4331
  foo__lower_case__field_indices_by_name,
4332
  1,  foo__lower_case__number_ranges,
4333
  (ProtobufCMessageInit) foo__lower_case__init,
4334
  NULL,NULL,NULL    /* reserved[123] */
4335
};
4336
static const ProtobufCFieldDescriptor foo__alloc_values__field_descriptors[5] =
4337
{
4338
  {
4339
    "o_bytes",
4340
    1,
4341
    PROTOBUF_C_LABEL_OPTIONAL,
4342
    PROTOBUF_C_TYPE_BYTES,
4343
    offsetof(Foo__AllocValues, has_o_bytes),
4344
    offsetof(Foo__AllocValues, o_bytes),
4345
    NULL,
4346
    NULL,
4347
    0,             /* flags */
4348
    0,NULL,NULL    /* reserved1,reserved2, etc */
4349
  },
4350
  {
4351
    "r_string",
4352
    2,
4353
    PROTOBUF_C_LABEL_REPEATED,
4354
    PROTOBUF_C_TYPE_STRING,
4355
    offsetof(Foo__AllocValues, n_r_string),
4356
    offsetof(Foo__AllocValues, r_string),
4357
    NULL,
4358
    NULL,
4359
    0,             /* flags */
4360
    0,NULL,NULL    /* reserved1,reserved2, etc */
4361
  },
4362
  {
4363
    "a_string",
4364
    3,
4365
    PROTOBUF_C_LABEL_REQUIRED,
4366
    PROTOBUF_C_TYPE_STRING,
4367
    0,   /* quantifier_offset */
4368
    offsetof(Foo__AllocValues, a_string),
4369
    NULL,
4370
    NULL,
4371
    0,             /* flags */
4372
    0,NULL,NULL    /* reserved1,reserved2, etc */
4373
  },
4374
  {
4375
    "a_bytes",
4376
    4,
4377
    PROTOBUF_C_LABEL_REQUIRED,
4378
    PROTOBUF_C_TYPE_BYTES,
4379
    0,   /* quantifier_offset */
4380
    offsetof(Foo__AllocValues, a_bytes),
4381
    NULL,
4382
    NULL,
4383
    0,             /* flags */
4384
    0,NULL,NULL    /* reserved1,reserved2, etc */
4385
  },
4386
  {
4387
    "a_mess",
4388
    5,
4389
    PROTOBUF_C_LABEL_REQUIRED,
4390
    PROTOBUF_C_TYPE_MESSAGE,
4391
    0,   /* quantifier_offset */
4392
    offsetof(Foo__AllocValues, a_mess),
4393
    &foo__default_required_values__descriptor,
4394
    NULL,
4395
    0,             /* flags */
4396
    0,NULL,NULL    /* reserved1,reserved2, etc */
4397
  },
4398
};
4399
static const unsigned foo__alloc_values__field_indices_by_name[] = {
4400
  3,   /* field[3] = a_bytes */
4401
  4,   /* field[4] = a_mess */
4402
  2,   /* field[2] = a_string */
4403
  0,   /* field[0] = o_bytes */
4404
  1,   /* field[1] = r_string */
4405
};
4406
static const ProtobufCIntRange foo__alloc_values__number_ranges[1 + 1] =
4407
{
4408
  { 1, 0 },
4409
  { 0, 5 }
4410
};
4411
const ProtobufCMessageDescriptor foo__alloc_values__descriptor =
4412
{
4413
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4414
  "foo.AllocValues",
4415
  "AllocValues",
4416
  "Foo__AllocValues",
4417
  "foo",
4418
  sizeof(Foo__AllocValues),
4419
  5,
4420
  foo__alloc_values__field_descriptors,
4421
  foo__alloc_values__field_indices_by_name,
4422
  1,  foo__alloc_values__number_ranges,
4423
  (ProtobufCMessageInit) foo__alloc_values__init,
4424
  NULL,NULL,NULL    /* reserved[123] */
4425
};
4426
static const ProtobufCFieldDescriptor foo__test_required_fields_bitmap__field_descriptors[129] =
4427
{
4428
  {
4429
    "field1",
4430
    1,
4431
    PROTOBUF_C_LABEL_REQUIRED,
4432
    PROTOBUF_C_TYPE_STRING,
4433
    0,   /* quantifier_offset */
4434
    offsetof(Foo__TestRequiredFieldsBitmap, field1),
4435
    NULL,
4436
    NULL,
4437
    0,             /* flags */
4438
    0,NULL,NULL    /* reserved1,reserved2, etc */
4439
  },
4440
  {
4441
    "field2",
4442
    2,
4443
    PROTOBUF_C_LABEL_OPTIONAL,
4444
    PROTOBUF_C_TYPE_STRING,
4445
    0,   /* quantifier_offset */
4446
    offsetof(Foo__TestRequiredFieldsBitmap, field2),
4447
    NULL,
4448
    NULL,
4449
    0,             /* flags */
4450
    0,NULL,NULL    /* reserved1,reserved2, etc */
4451
  },
4452
  {
4453
    "field3",
4454
    3,
4455
    PROTOBUF_C_LABEL_OPTIONAL,
4456
    PROTOBUF_C_TYPE_STRING,
4457
    0,   /* quantifier_offset */
4458
    offsetof(Foo__TestRequiredFieldsBitmap, field3),
4459
    NULL,
4460
    NULL,
4461
    0,             /* flags */
4462
    0,NULL,NULL    /* reserved1,reserved2, etc */
4463
  },
4464
  {
4465
    "field4",
4466
    4,
4467
    PROTOBUF_C_LABEL_OPTIONAL,
4468
    PROTOBUF_C_TYPE_STRING,
4469
    0,   /* quantifier_offset */
4470
    offsetof(Foo__TestRequiredFieldsBitmap, field4),
4471
    NULL,
4472
    NULL,
4473
    0,             /* flags */
4474
    0,NULL,NULL    /* reserved1,reserved2, etc */
4475
  },
4476
  {
4477
    "field5",
4478
    5,
4479
    PROTOBUF_C_LABEL_OPTIONAL,
4480
    PROTOBUF_C_TYPE_STRING,
4481
    0,   /* quantifier_offset */
4482
    offsetof(Foo__TestRequiredFieldsBitmap, field5),
4483
    NULL,
4484
    NULL,
4485
    0,             /* flags */
4486
    0,NULL,NULL    /* reserved1,reserved2, etc */
4487
  },
4488
  {
4489
    "field6",
4490
    6,
4491
    PROTOBUF_C_LABEL_OPTIONAL,
4492
    PROTOBUF_C_TYPE_STRING,
4493
    0,   /* quantifier_offset */
4494
    offsetof(Foo__TestRequiredFieldsBitmap, field6),
4495
    NULL,
4496
    NULL,
4497
    0,             /* flags */
4498
    0,NULL,NULL    /* reserved1,reserved2, etc */
4499
  },
4500
  {
4501
    "field7",
4502
    7,
4503
    PROTOBUF_C_LABEL_OPTIONAL,
4504
    PROTOBUF_C_TYPE_STRING,
4505
    0,   /* quantifier_offset */
4506
    offsetof(Foo__TestRequiredFieldsBitmap, field7),
4507
    NULL,
4508
    NULL,
4509
    0,             /* flags */
4510
    0,NULL,NULL    /* reserved1,reserved2, etc */
4511
  },
4512
  {
4513
    "field8",
4514
    8,
4515
    PROTOBUF_C_LABEL_OPTIONAL,
4516
    PROTOBUF_C_TYPE_STRING,
4517
    0,   /* quantifier_offset */
4518
    offsetof(Foo__TestRequiredFieldsBitmap, field8),
4519
    NULL,
4520
    NULL,
4521
    0,             /* flags */
4522
    0,NULL,NULL    /* reserved1,reserved2, etc */
4523
  },
4524
  {
4525
    "field9",
4526
    9,
4527
    PROTOBUF_C_LABEL_OPTIONAL,
4528
    PROTOBUF_C_TYPE_STRING,
4529
    0,   /* quantifier_offset */
4530
    offsetof(Foo__TestRequiredFieldsBitmap, field9),
4531
    NULL,
4532
    NULL,
4533
    0,             /* flags */
4534
    0,NULL,NULL    /* reserved1,reserved2, etc */
4535
  },
4536
  {
4537
    "field10",
4538
    10,
4539
    PROTOBUF_C_LABEL_OPTIONAL,
4540
    PROTOBUF_C_TYPE_STRING,
4541
    0,   /* quantifier_offset */
4542
    offsetof(Foo__TestRequiredFieldsBitmap, field10),
4543
    NULL,
4544
    NULL,
4545
    0,             /* flags */
4546
    0,NULL,NULL    /* reserved1,reserved2, etc */
4547
  },
4548
  {
4549
    "field11",
4550
    11,
4551
    PROTOBUF_C_LABEL_OPTIONAL,
4552
    PROTOBUF_C_TYPE_STRING,
4553
    0,   /* quantifier_offset */
4554
    offsetof(Foo__TestRequiredFieldsBitmap, field11),
4555
    NULL,
4556
    NULL,
4557
    0,             /* flags */
4558
    0,NULL,NULL    /* reserved1,reserved2, etc */
4559
  },
4560
  {
4561
    "field12",
4562
    12,
4563
    PROTOBUF_C_LABEL_OPTIONAL,
4564
    PROTOBUF_C_TYPE_STRING,
4565
    0,   /* quantifier_offset */
4566
    offsetof(Foo__TestRequiredFieldsBitmap, field12),
4567
    NULL,
4568
    NULL,
4569
    0,             /* flags */
4570
    0,NULL,NULL    /* reserved1,reserved2, etc */
4571
  },
4572
  {
4573
    "field13",
4574
    13,
4575
    PROTOBUF_C_LABEL_OPTIONAL,
4576
    PROTOBUF_C_TYPE_STRING,
4577
    0,   /* quantifier_offset */
4578
    offsetof(Foo__TestRequiredFieldsBitmap, field13),
4579
    NULL,
4580
    NULL,
4581
    0,             /* flags */
4582
    0,NULL,NULL    /* reserved1,reserved2, etc */
4583
  },
4584
  {
4585
    "field14",
4586
    14,
4587
    PROTOBUF_C_LABEL_OPTIONAL,
4588
    PROTOBUF_C_TYPE_STRING,
4589
    0,   /* quantifier_offset */
4590
    offsetof(Foo__TestRequiredFieldsBitmap, field14),
4591
    NULL,
4592
    NULL,
4593
    0,             /* flags */
4594
    0,NULL,NULL    /* reserved1,reserved2, etc */
4595
  },
4596
  {
4597
    "field15",
4598
    15,
4599
    PROTOBUF_C_LABEL_OPTIONAL,
4600
    PROTOBUF_C_TYPE_STRING,
4601
    0,   /* quantifier_offset */
4602
    offsetof(Foo__TestRequiredFieldsBitmap, field15),
4603
    NULL,
4604
    NULL,
4605
    0,             /* flags */
4606
    0,NULL,NULL    /* reserved1,reserved2, etc */
4607
  },
4608
  {
4609
    "field16",
4610
    16,
4611
    PROTOBUF_C_LABEL_OPTIONAL,
4612
    PROTOBUF_C_TYPE_STRING,
4613
    0,   /* quantifier_offset */
4614
    offsetof(Foo__TestRequiredFieldsBitmap, field16),
4615
    NULL,
4616
    NULL,
4617
    0,             /* flags */
4618
    0,NULL,NULL    /* reserved1,reserved2, etc */
4619
  },
4620
  {
4621
    "field17",
4622
    17,
4623
    PROTOBUF_C_LABEL_OPTIONAL,
4624
    PROTOBUF_C_TYPE_STRING,
4625
    0,   /* quantifier_offset */
4626
    offsetof(Foo__TestRequiredFieldsBitmap, field17),
4627
    NULL,
4628
    NULL,
4629
    0,             /* flags */
4630
    0,NULL,NULL    /* reserved1,reserved2, etc */
4631
  },
4632
  {
4633
    "field18",
4634
    18,
4635
    PROTOBUF_C_LABEL_OPTIONAL,
4636
    PROTOBUF_C_TYPE_STRING,
4637
    0,   /* quantifier_offset */
4638
    offsetof(Foo__TestRequiredFieldsBitmap, field18),
4639
    NULL,
4640
    NULL,
4641
    0,             /* flags */
4642
    0,NULL,NULL    /* reserved1,reserved2, etc */
4643
  },
4644
  {
4645
    "field19",
4646
    19,
4647
    PROTOBUF_C_LABEL_OPTIONAL,
4648
    PROTOBUF_C_TYPE_STRING,
4649
    0,   /* quantifier_offset */
4650
    offsetof(Foo__TestRequiredFieldsBitmap, field19),
4651
    NULL,
4652
    NULL,
4653
    0,             /* flags */
4654
    0,NULL,NULL    /* reserved1,reserved2, etc */
4655
  },
4656
  {
4657
    "field20",
4658
    20,
4659
    PROTOBUF_C_LABEL_OPTIONAL,
4660
    PROTOBUF_C_TYPE_STRING,
4661
    0,   /* quantifier_offset */
4662
    offsetof(Foo__TestRequiredFieldsBitmap, field20),
4663
    NULL,
4664
    NULL,
4665
    0,             /* flags */
4666
    0,NULL,NULL    /* reserved1,reserved2, etc */
4667
  },
4668
  {
4669
    "field21",
4670
    21,
4671
    PROTOBUF_C_LABEL_OPTIONAL,
4672
    PROTOBUF_C_TYPE_STRING,
4673
    0,   /* quantifier_offset */
4674
    offsetof(Foo__TestRequiredFieldsBitmap, field21),
4675
    NULL,
4676
    NULL,
4677
    0,             /* flags */
4678
    0,NULL,NULL    /* reserved1,reserved2, etc */
4679
  },
4680
  {
4681
    "field22",
4682
    22,
4683
    PROTOBUF_C_LABEL_OPTIONAL,
4684
    PROTOBUF_C_TYPE_STRING,
4685
    0,   /* quantifier_offset */
4686
    offsetof(Foo__TestRequiredFieldsBitmap, field22),
4687
    NULL,
4688
    NULL,
4689
    0,             /* flags */
4690
    0,NULL,NULL    /* reserved1,reserved2, etc */
4691
  },
4692
  {
4693
    "field23",
4694
    23,
4695
    PROTOBUF_C_LABEL_OPTIONAL,
4696
    PROTOBUF_C_TYPE_STRING,
4697
    0,   /* quantifier_offset */
4698
    offsetof(Foo__TestRequiredFieldsBitmap, field23),
4699
    NULL,
4700
    NULL,
4701
    0,             /* flags */
4702
    0,NULL,NULL    /* reserved1,reserved2, etc */
4703
  },
4704
  {
4705
    "field24",
4706
    24,
4707
    PROTOBUF_C_LABEL_OPTIONAL,
4708
    PROTOBUF_C_TYPE_STRING,
4709
    0,   /* quantifier_offset */
4710
    offsetof(Foo__TestRequiredFieldsBitmap, field24),
4711
    NULL,
4712
    NULL,
4713
    0,             /* flags */
4714
    0,NULL,NULL    /* reserved1,reserved2, etc */
4715
  },
4716
  {
4717
    "field25",
4718
    25,
4719
    PROTOBUF_C_LABEL_OPTIONAL,
4720
    PROTOBUF_C_TYPE_STRING,
4721
    0,   /* quantifier_offset */
4722
    offsetof(Foo__TestRequiredFieldsBitmap, field25),
4723
    NULL,
4724
    NULL,
4725
    0,             /* flags */
4726
    0,NULL,NULL    /* reserved1,reserved2, etc */
4727
  },
4728
  {
4729
    "field26",
4730
    26,
4731
    PROTOBUF_C_LABEL_OPTIONAL,
4732
    PROTOBUF_C_TYPE_STRING,
4733
    0,   /* quantifier_offset */
4734
    offsetof(Foo__TestRequiredFieldsBitmap, field26),
4735
    NULL,
4736
    NULL,
4737
    0,             /* flags */
4738
    0,NULL,NULL    /* reserved1,reserved2, etc */
4739
  },
4740
  {
4741
    "field27",
4742
    27,
4743
    PROTOBUF_C_LABEL_OPTIONAL,
4744
    PROTOBUF_C_TYPE_STRING,
4745
    0,   /* quantifier_offset */
4746
    offsetof(Foo__TestRequiredFieldsBitmap, field27),
4747
    NULL,
4748
    NULL,
4749
    0,             /* flags */
4750
    0,NULL,NULL    /* reserved1,reserved2, etc */
4751
  },
4752
  {
4753
    "field28",
4754
    28,
4755
    PROTOBUF_C_LABEL_OPTIONAL,
4756
    PROTOBUF_C_TYPE_STRING,
4757
    0,   /* quantifier_offset */
4758
    offsetof(Foo__TestRequiredFieldsBitmap, field28),
4759
    NULL,
4760
    NULL,
4761
    0,             /* flags */
4762
    0,NULL,NULL    /* reserved1,reserved2, etc */
4763
  },
4764
  {
4765
    "field29",
4766
    29,
4767
    PROTOBUF_C_LABEL_OPTIONAL,
4768
    PROTOBUF_C_TYPE_STRING,
4769
    0,   /* quantifier_offset */
4770
    offsetof(Foo__TestRequiredFieldsBitmap, field29),
4771
    NULL,
4772
    NULL,
4773
    0,             /* flags */
4774
    0,NULL,NULL    /* reserved1,reserved2, etc */
4775
  },
4776
  {
4777
    "field30",
4778
    30,
4779
    PROTOBUF_C_LABEL_OPTIONAL,
4780
    PROTOBUF_C_TYPE_STRING,
4781
    0,   /* quantifier_offset */
4782
    offsetof(Foo__TestRequiredFieldsBitmap, field30),
4783
    NULL,
4784
    NULL,
4785
    0,             /* flags */
4786
    0,NULL,NULL    /* reserved1,reserved2, etc */
4787
  },
4788
  {
4789
    "field31",
4790
    31,
4791
    PROTOBUF_C_LABEL_OPTIONAL,
4792
    PROTOBUF_C_TYPE_STRING,
4793
    0,   /* quantifier_offset */
4794
    offsetof(Foo__TestRequiredFieldsBitmap, field31),
4795
    NULL,
4796
    NULL,
4797
    0,             /* flags */
4798
    0,NULL,NULL    /* reserved1,reserved2, etc */
4799
  },
4800
  {
4801
    "field32",
4802
    32,
4803
    PROTOBUF_C_LABEL_OPTIONAL,
4804
    PROTOBUF_C_TYPE_STRING,
4805
    0,   /* quantifier_offset */
4806
    offsetof(Foo__TestRequiredFieldsBitmap, field32),
4807
    NULL,
4808
    NULL,
4809
    0,             /* flags */
4810
    0,NULL,NULL    /* reserved1,reserved2, etc */
4811
  },
4812
  {
4813
    "field33",
4814
    33,
4815
    PROTOBUF_C_LABEL_OPTIONAL,
4816
    PROTOBUF_C_TYPE_STRING,
4817
    0,   /* quantifier_offset */
4818
    offsetof(Foo__TestRequiredFieldsBitmap, field33),
4819
    NULL,
4820
    NULL,
4821
    0,             /* flags */
4822
    0,NULL,NULL    /* reserved1,reserved2, etc */
4823
  },
4824
  {
4825
    "field34",
4826
    34,
4827
    PROTOBUF_C_LABEL_OPTIONAL,
4828
    PROTOBUF_C_TYPE_STRING,
4829
    0,   /* quantifier_offset */
4830
    offsetof(Foo__TestRequiredFieldsBitmap, field34),
4831
    NULL,
4832
    NULL,
4833
    0,             /* flags */
4834
    0,NULL,NULL    /* reserved1,reserved2, etc */
4835
  },
4836
  {
4837
    "field35",
4838
    35,
4839
    PROTOBUF_C_LABEL_OPTIONAL,
4840
    PROTOBUF_C_TYPE_STRING,
4841
    0,   /* quantifier_offset */
4842
    offsetof(Foo__TestRequiredFieldsBitmap, field35),
4843
    NULL,
4844
    NULL,
4845
    0,             /* flags */
4846
    0,NULL,NULL    /* reserved1,reserved2, etc */
4847
  },
4848
  {
4849
    "field36",
4850
    36,
4851
    PROTOBUF_C_LABEL_OPTIONAL,
4852
    PROTOBUF_C_TYPE_STRING,
4853
    0,   /* quantifier_offset */
4854
    offsetof(Foo__TestRequiredFieldsBitmap, field36),
4855
    NULL,
4856
    NULL,
4857
    0,             /* flags */
4858
    0,NULL,NULL    /* reserved1,reserved2, etc */
4859
  },
4860
  {
4861
    "field37",
4862
    37,
4863
    PROTOBUF_C_LABEL_OPTIONAL,
4864
    PROTOBUF_C_TYPE_STRING,
4865
    0,   /* quantifier_offset */
4866
    offsetof(Foo__TestRequiredFieldsBitmap, field37),
4867
    NULL,
4868
    NULL,
4869
    0,             /* flags */
4870
    0,NULL,NULL    /* reserved1,reserved2, etc */
4871
  },
4872
  {
4873
    "field38",
4874
    38,
4875
    PROTOBUF_C_LABEL_OPTIONAL,
4876
    PROTOBUF_C_TYPE_STRING,
4877
    0,   /* quantifier_offset */
4878
    offsetof(Foo__TestRequiredFieldsBitmap, field38),
4879
    NULL,
4880
    NULL,
4881
    0,             /* flags */
4882
    0,NULL,NULL    /* reserved1,reserved2, etc */
4883
  },
4884
  {
4885
    "field39",
4886
    39,
4887
    PROTOBUF_C_LABEL_OPTIONAL,
4888
    PROTOBUF_C_TYPE_STRING,
4889
    0,   /* quantifier_offset */
4890
    offsetof(Foo__TestRequiredFieldsBitmap, field39),
4891
    NULL,
4892
    NULL,
4893
    0,             /* flags */
4894
    0,NULL,NULL    /* reserved1,reserved2, etc */
4895
  },
4896
  {
4897
    "field40",
4898
    40,
4899
    PROTOBUF_C_LABEL_OPTIONAL,
4900
    PROTOBUF_C_TYPE_STRING,
4901
    0,   /* quantifier_offset */
4902
    offsetof(Foo__TestRequiredFieldsBitmap, field40),
4903
    NULL,
4904
    NULL,
4905
    0,             /* flags */
4906
    0,NULL,NULL    /* reserved1,reserved2, etc */
4907
  },
4908
  {
4909
    "field41",
4910
    41,
4911
    PROTOBUF_C_LABEL_OPTIONAL,
4912
    PROTOBUF_C_TYPE_STRING,
4913
    0,   /* quantifier_offset */
4914
    offsetof(Foo__TestRequiredFieldsBitmap, field41),
4915
    NULL,
4916
    NULL,
4917
    0,             /* flags */
4918
    0,NULL,NULL    /* reserved1,reserved2, etc */
4919
  },
4920
  {
4921
    "field42",
4922
    42,
4923
    PROTOBUF_C_LABEL_OPTIONAL,
4924
    PROTOBUF_C_TYPE_STRING,
4925
    0,   /* quantifier_offset */
4926
    offsetof(Foo__TestRequiredFieldsBitmap, field42),
4927
    NULL,
4928
    NULL,
4929
    0,             /* flags */
4930
    0,NULL,NULL    /* reserved1,reserved2, etc */
4931
  },
4932
  {
4933
    "field43",
4934
    43,
4935
    PROTOBUF_C_LABEL_OPTIONAL,
4936
    PROTOBUF_C_TYPE_STRING,
4937
    0,   /* quantifier_offset */
4938
    offsetof(Foo__TestRequiredFieldsBitmap, field43),
4939
    NULL,
4940
    NULL,
4941
    0,             /* flags */
4942
    0,NULL,NULL    /* reserved1,reserved2, etc */
4943
  },
4944
  {
4945
    "field44",
4946
    44,
4947
    PROTOBUF_C_LABEL_OPTIONAL,
4948
    PROTOBUF_C_TYPE_STRING,
4949
    0,   /* quantifier_offset */
4950
    offsetof(Foo__TestRequiredFieldsBitmap, field44),
4951
    NULL,
4952
    NULL,
4953
    0,             /* flags */
4954
    0,NULL,NULL    /* reserved1,reserved2, etc */
4955
  },
4956
  {
4957
    "field45",
4958
    45,
4959
    PROTOBUF_C_LABEL_OPTIONAL,
4960
    PROTOBUF_C_TYPE_STRING,
4961
    0,   /* quantifier_offset */
4962
    offsetof(Foo__TestRequiredFieldsBitmap, field45),
4963
    NULL,
4964
    NULL,
4965
    0,             /* flags */
4966
    0,NULL,NULL    /* reserved1,reserved2, etc */
4967
  },
4968
  {
4969
    "field46",
4970
    46,
4971
    PROTOBUF_C_LABEL_OPTIONAL,
4972
    PROTOBUF_C_TYPE_STRING,
4973
    0,   /* quantifier_offset */
4974
    offsetof(Foo__TestRequiredFieldsBitmap, field46),
4975
    NULL,
4976
    NULL,
4977
    0,             /* flags */
4978
    0,NULL,NULL    /* reserved1,reserved2, etc */
4979
  },
4980
  {
4981
    "field47",
4982
    47,
4983
    PROTOBUF_C_LABEL_OPTIONAL,
4984
    PROTOBUF_C_TYPE_STRING,
4985
    0,   /* quantifier_offset */
4986
    offsetof(Foo__TestRequiredFieldsBitmap, field47),
4987
    NULL,
4988
    NULL,
4989
    0,             /* flags */
4990
    0,NULL,NULL    /* reserved1,reserved2, etc */
4991
  },
4992
  {
4993
    "field48",
4994
    48,
4995
    PROTOBUF_C_LABEL_OPTIONAL,
4996
    PROTOBUF_C_TYPE_STRING,
4997
    0,   /* quantifier_offset */
4998
    offsetof(Foo__TestRequiredFieldsBitmap, field48),
4999
    NULL,
5000
    NULL,
5001
    0,             /* flags */
5002
    0,NULL,NULL    /* reserved1,reserved2, etc */
5003
  },
5004
  {
5005
    "field49",
5006
    49,
5007
    PROTOBUF_C_LABEL_OPTIONAL,
5008
    PROTOBUF_C_TYPE_STRING,
5009
    0,   /* quantifier_offset */
5010
    offsetof(Foo__TestRequiredFieldsBitmap, field49),
5011
    NULL,
5012
    NULL,
5013
    0,             /* flags */
5014
    0,NULL,NULL    /* reserved1,reserved2, etc */
5015
  },
5016
  {
5017
    "field50",
5018
    50,
5019
    PROTOBUF_C_LABEL_OPTIONAL,
5020
    PROTOBUF_C_TYPE_STRING,
5021
    0,   /* quantifier_offset */
5022
    offsetof(Foo__TestRequiredFieldsBitmap, field50),
5023
    NULL,
5024
    NULL,
5025
    0,             /* flags */
5026
    0,NULL,NULL    /* reserved1,reserved2, etc */
5027
  },
5028
  {
5029
    "field51",
5030
    51,
5031
    PROTOBUF_C_LABEL_OPTIONAL,
5032
    PROTOBUF_C_TYPE_STRING,
5033
    0,   /* quantifier_offset */
5034
    offsetof(Foo__TestRequiredFieldsBitmap, field51),
5035
    NULL,
5036
    NULL,
5037
    0,             /* flags */
5038
    0,NULL,NULL    /* reserved1,reserved2, etc */
5039
  },
5040
  {
5041
    "field52",
5042
    52,
5043
    PROTOBUF_C_LABEL_OPTIONAL,
5044
    PROTOBUF_C_TYPE_STRING,
5045
    0,   /* quantifier_offset */
5046
    offsetof(Foo__TestRequiredFieldsBitmap, field52),
5047
    NULL,
5048
    NULL,
5049
    0,             /* flags */
5050
    0,NULL,NULL    /* reserved1,reserved2, etc */
5051
  },
5052
  {
5053
    "field53",
5054
    53,
5055
    PROTOBUF_C_LABEL_OPTIONAL,
5056
    PROTOBUF_C_TYPE_STRING,
5057
    0,   /* quantifier_offset */
5058
    offsetof(Foo__TestRequiredFieldsBitmap, field53),
5059
    NULL,
5060
    NULL,
5061
    0,             /* flags */
5062
    0,NULL,NULL    /* reserved1,reserved2, etc */
5063
  },
5064
  {
5065
    "field54",
5066
    54,
5067
    PROTOBUF_C_LABEL_OPTIONAL,
5068
    PROTOBUF_C_TYPE_STRING,
5069
    0,   /* quantifier_offset */
5070
    offsetof(Foo__TestRequiredFieldsBitmap, field54),
5071
    NULL,
5072
    NULL,
5073
    0,             /* flags */
5074
    0,NULL,NULL    /* reserved1,reserved2, etc */
5075
  },
5076
  {
5077
    "field55",
5078
    55,
5079
    PROTOBUF_C_LABEL_OPTIONAL,
5080
    PROTOBUF_C_TYPE_STRING,
5081
    0,   /* quantifier_offset */
5082
    offsetof(Foo__TestRequiredFieldsBitmap, field55),
5083
    NULL,
5084
    NULL,
5085
    0,             /* flags */
5086
    0,NULL,NULL    /* reserved1,reserved2, etc */
5087
  },
5088
  {
5089
    "field56",
5090
    56,
5091
    PROTOBUF_C_LABEL_OPTIONAL,
5092
    PROTOBUF_C_TYPE_STRING,
5093
    0,   /* quantifier_offset */
5094
    offsetof(Foo__TestRequiredFieldsBitmap, field56),
5095
    NULL,
5096
    NULL,
5097
    0,             /* flags */
5098
    0,NULL,NULL    /* reserved1,reserved2, etc */
5099
  },
5100
  {
5101
    "field57",
5102
    57,
5103
    PROTOBUF_C_LABEL_OPTIONAL,
5104
    PROTOBUF_C_TYPE_STRING,
5105
    0,   /* quantifier_offset */
5106
    offsetof(Foo__TestRequiredFieldsBitmap, field57),
5107
    NULL,
5108
    NULL,
5109
    0,             /* flags */
5110
    0,NULL,NULL    /* reserved1,reserved2, etc */
5111
  },
5112
  {
5113
    "field58",
5114
    58,
5115
    PROTOBUF_C_LABEL_OPTIONAL,
5116
    PROTOBUF_C_TYPE_STRING,
5117
    0,   /* quantifier_offset */
5118
    offsetof(Foo__TestRequiredFieldsBitmap, field58),
5119
    NULL,
5120
    NULL,
5121
    0,             /* flags */
5122
    0,NULL,NULL    /* reserved1,reserved2, etc */
5123
  },
5124
  {
5125
    "field59",
5126
    59,
5127
    PROTOBUF_C_LABEL_OPTIONAL,
5128
    PROTOBUF_C_TYPE_STRING,
5129
    0,   /* quantifier_offset */
5130
    offsetof(Foo__TestRequiredFieldsBitmap, field59),
5131
    NULL,
5132
    NULL,
5133
    0,             /* flags */
5134
    0,NULL,NULL    /* reserved1,reserved2, etc */
5135
  },
5136
  {
5137
    "field60",
5138
    60,
5139
    PROTOBUF_C_LABEL_OPTIONAL,
5140
    PROTOBUF_C_TYPE_STRING,
5141
    0,   /* quantifier_offset */
5142
    offsetof(Foo__TestRequiredFieldsBitmap, field60),
5143
    NULL,
5144
    NULL,
5145
    0,             /* flags */
5146
    0,NULL,NULL    /* reserved1,reserved2, etc */
5147
  },
5148
  {
5149
    "field61",
5150
    61,
5151
    PROTOBUF_C_LABEL_OPTIONAL,
5152
    PROTOBUF_C_TYPE_STRING,
5153
    0,   /* quantifier_offset */
5154
    offsetof(Foo__TestRequiredFieldsBitmap, field61),
5155
    NULL,
5156
    NULL,
5157
    0,             /* flags */
5158
    0,NULL,NULL    /* reserved1,reserved2, etc */
5159
  },
5160
  {
5161
    "field62",
5162
    62,
5163
    PROTOBUF_C_LABEL_OPTIONAL,
5164
    PROTOBUF_C_TYPE_STRING,
5165
    0,   /* quantifier_offset */
5166
    offsetof(Foo__TestRequiredFieldsBitmap, field62),
5167
    NULL,
5168
    NULL,
5169
    0,             /* flags */
5170
    0,NULL,NULL    /* reserved1,reserved2, etc */
5171
  },
5172
  {
5173
    "field63",
5174
    63,
5175
    PROTOBUF_C_LABEL_OPTIONAL,
5176
    PROTOBUF_C_TYPE_STRING,
5177
    0,   /* quantifier_offset */
5178
    offsetof(Foo__TestRequiredFieldsBitmap, field63),
5179
    NULL,
5180
    NULL,
5181
    0,             /* flags */
5182
    0,NULL,NULL    /* reserved1,reserved2, etc */
5183
  },
5184
  {
5185
    "field64",
5186
    64,
5187
    PROTOBUF_C_LABEL_OPTIONAL,
5188
    PROTOBUF_C_TYPE_STRING,
5189
    0,   /* quantifier_offset */
5190
    offsetof(Foo__TestRequiredFieldsBitmap, field64),
5191
    NULL,
5192
    NULL,
5193
    0,             /* flags */
5194
    0,NULL,NULL    /* reserved1,reserved2, etc */
5195
  },
5196
  {
5197
    "field65",
5198
    65,
5199
    PROTOBUF_C_LABEL_OPTIONAL,
5200
    PROTOBUF_C_TYPE_STRING,
5201
    0,   /* quantifier_offset */
5202
    offsetof(Foo__TestRequiredFieldsBitmap, field65),
5203
    NULL,
5204
    NULL,
5205
    0,             /* flags */
5206
    0,NULL,NULL    /* reserved1,reserved2, etc */
5207
  },
5208
  {
5209
    "field66",
5210
    66,
5211
    PROTOBUF_C_LABEL_OPTIONAL,
5212
    PROTOBUF_C_TYPE_STRING,
5213
    0,   /* quantifier_offset */
5214
    offsetof(Foo__TestRequiredFieldsBitmap, field66),
5215
    NULL,
5216
    NULL,
5217
    0,             /* flags */
5218
    0,NULL,NULL    /* reserved1,reserved2, etc */
5219
  },
5220
  {
5221
    "field67",
5222
    67,
5223
    PROTOBUF_C_LABEL_OPTIONAL,
5224
    PROTOBUF_C_TYPE_STRING,
5225
    0,   /* quantifier_offset */
5226
    offsetof(Foo__TestRequiredFieldsBitmap, field67),
5227
    NULL,
5228
    NULL,
5229
    0,             /* flags */
5230
    0,NULL,NULL    /* reserved1,reserved2, etc */
5231
  },
5232
  {
5233
    "field68",
5234
    68,
5235
    PROTOBUF_C_LABEL_OPTIONAL,
5236
    PROTOBUF_C_TYPE_STRING,
5237
    0,   /* quantifier_offset */
5238
    offsetof(Foo__TestRequiredFieldsBitmap, field68),
5239
    NULL,
5240
    NULL,
5241
    0,             /* flags */
5242
    0,NULL,NULL    /* reserved1,reserved2, etc */
5243
  },
5244
  {
5245
    "field69",
5246
    69,
5247
    PROTOBUF_C_LABEL_OPTIONAL,
5248
    PROTOBUF_C_TYPE_STRING,
5249
    0,   /* quantifier_offset */
5250
    offsetof(Foo__TestRequiredFieldsBitmap, field69),
5251
    NULL,
5252
    NULL,
5253
    0,             /* flags */
5254
    0,NULL,NULL    /* reserved1,reserved2, etc */
5255
  },
5256
  {
5257
    "field70",
5258
    70,
5259
    PROTOBUF_C_LABEL_OPTIONAL,
5260
    PROTOBUF_C_TYPE_STRING,
5261
    0,   /* quantifier_offset */
5262
    offsetof(Foo__TestRequiredFieldsBitmap, field70),
5263
    NULL,
5264
    NULL,
5265
    0,             /* flags */
5266
    0,NULL,NULL    /* reserved1,reserved2, etc */
5267
  },
5268
  {
5269
    "field71",
5270
    71,
5271
    PROTOBUF_C_LABEL_OPTIONAL,
5272
    PROTOBUF_C_TYPE_STRING,
5273
    0,   /* quantifier_offset */
5274
    offsetof(Foo__TestRequiredFieldsBitmap, field71),
5275
    NULL,
5276
    NULL,
5277
    0,             /* flags */
5278
    0,NULL,NULL    /* reserved1,reserved2, etc */
5279
  },
5280
  {
5281
    "field72",
5282
    72,
5283
    PROTOBUF_C_LABEL_OPTIONAL,
5284
    PROTOBUF_C_TYPE_STRING,
5285
    0,   /* quantifier_offset */
5286
    offsetof(Foo__TestRequiredFieldsBitmap, field72),
5287
    NULL,
5288
    NULL,
5289
    0,             /* flags */
5290
    0,NULL,NULL    /* reserved1,reserved2, etc */
5291
  },
5292
  {
5293
    "field73",
5294
    73,
5295
    PROTOBUF_C_LABEL_OPTIONAL,
5296
    PROTOBUF_C_TYPE_STRING,
5297
    0,   /* quantifier_offset */
5298
    offsetof(Foo__TestRequiredFieldsBitmap, field73),
5299
    NULL,
5300
    NULL,
5301
    0,             /* flags */
5302
    0,NULL,NULL    /* reserved1,reserved2, etc */
5303
  },
5304
  {
5305
    "field74",
5306
    74,
5307
    PROTOBUF_C_LABEL_OPTIONAL,
5308
    PROTOBUF_C_TYPE_STRING,
5309
    0,   /* quantifier_offset */
5310
    offsetof(Foo__TestRequiredFieldsBitmap, field74),
5311
    NULL,
5312
    NULL,
5313
    0,             /* flags */
5314
    0,NULL,NULL    /* reserved1,reserved2, etc */
5315
  },
5316
  {
5317
    "field75",
5318
    75,
5319
    PROTOBUF_C_LABEL_OPTIONAL,
5320
    PROTOBUF_C_TYPE_STRING,
5321
    0,   /* quantifier_offset */
5322
    offsetof(Foo__TestRequiredFieldsBitmap, field75),
5323
    NULL,
5324
    NULL,
5325
    0,             /* flags */
5326
    0,NULL,NULL    /* reserved1,reserved2, etc */
5327
  },
5328
  {
5329
    "field76",
5330
    76,
5331
    PROTOBUF_C_LABEL_OPTIONAL,
5332
    PROTOBUF_C_TYPE_STRING,
5333
    0,   /* quantifier_offset */
5334
    offsetof(Foo__TestRequiredFieldsBitmap, field76),
5335
    NULL,
5336
    NULL,
5337
    0,             /* flags */
5338
    0,NULL,NULL    /* reserved1,reserved2, etc */
5339
  },
5340
  {
5341
    "field77",
5342
    77,
5343
    PROTOBUF_C_LABEL_OPTIONAL,
5344
    PROTOBUF_C_TYPE_STRING,
5345
    0,   /* quantifier_offset */
5346
    offsetof(Foo__TestRequiredFieldsBitmap, field77),
5347
    NULL,
5348
    NULL,
5349
    0,             /* flags */
5350
    0,NULL,NULL    /* reserved1,reserved2, etc */
5351
  },
5352
  {
5353
    "field78",
5354
    78,
5355
    PROTOBUF_C_LABEL_OPTIONAL,
5356
    PROTOBUF_C_TYPE_STRING,
5357
    0,   /* quantifier_offset */
5358
    offsetof(Foo__TestRequiredFieldsBitmap, field78),
5359
    NULL,
5360
    NULL,
5361
    0,             /* flags */
5362
    0,NULL,NULL    /* reserved1,reserved2, etc */
5363
  },
5364
  {
5365
    "field79",
5366
    79,
5367
    PROTOBUF_C_LABEL_OPTIONAL,
5368
    PROTOBUF_C_TYPE_STRING,
5369
    0,   /* quantifier_offset */
5370
    offsetof(Foo__TestRequiredFieldsBitmap, field79),
5371
    NULL,
5372
    NULL,
5373
    0,             /* flags */
5374
    0,NULL,NULL    /* reserved1,reserved2, etc */
5375
  },
5376
  {
5377
    "field80",
5378
    80,
5379
    PROTOBUF_C_LABEL_OPTIONAL,
5380
    PROTOBUF_C_TYPE_STRING,
5381
    0,   /* quantifier_offset */
5382
    offsetof(Foo__TestRequiredFieldsBitmap, field80),
5383
    NULL,
5384
    NULL,
5385
    0,             /* flags */
5386
    0,NULL,NULL    /* reserved1,reserved2, etc */
5387
  },
5388
  {
5389
    "field81",
5390
    81,
5391
    PROTOBUF_C_LABEL_OPTIONAL,
5392
    PROTOBUF_C_TYPE_STRING,
5393
    0,   /* quantifier_offset */
5394
    offsetof(Foo__TestRequiredFieldsBitmap, field81),
5395
    NULL,
5396
    NULL,
5397
    0,             /* flags */
5398
    0,NULL,NULL    /* reserved1,reserved2, etc */
5399
  },
5400
  {
5401
    "field82",
5402
    82,
5403
    PROTOBUF_C_LABEL_OPTIONAL,
5404
    PROTOBUF_C_TYPE_STRING,
5405
    0,   /* quantifier_offset */
5406
    offsetof(Foo__TestRequiredFieldsBitmap, field82),
5407
    NULL,
5408
    NULL,
5409
    0,             /* flags */
5410
    0,NULL,NULL    /* reserved1,reserved2, etc */
5411
  },
5412
  {
5413
    "field83",
5414
    83,
5415
    PROTOBUF_C_LABEL_OPTIONAL,
5416
    PROTOBUF_C_TYPE_STRING,
5417
    0,   /* quantifier_offset */
5418
    offsetof(Foo__TestRequiredFieldsBitmap, field83),
5419
    NULL,
5420
    NULL,
5421
    0,             /* flags */
5422
    0,NULL,NULL    /* reserved1,reserved2, etc */
5423
  },
5424
  {
5425
    "field84",
5426
    84,
5427
    PROTOBUF_C_LABEL_OPTIONAL,
5428
    PROTOBUF_C_TYPE_STRING,
5429
    0,   /* quantifier_offset */
5430
    offsetof(Foo__TestRequiredFieldsBitmap, field84),
5431
    NULL,
5432
    NULL,
5433
    0,             /* flags */
5434
    0,NULL,NULL    /* reserved1,reserved2, etc */
5435
  },
5436
  {
5437
    "field85",
5438
    85,
5439
    PROTOBUF_C_LABEL_OPTIONAL,
5440
    PROTOBUF_C_TYPE_STRING,
5441
    0,   /* quantifier_offset */
5442
    offsetof(Foo__TestRequiredFieldsBitmap, field85),
5443
    NULL,
5444
    NULL,
5445
    0,             /* flags */
5446
    0,NULL,NULL    /* reserved1,reserved2, etc */
5447
  },
5448
  {
5449
    "field86",
5450
    86,
5451
    PROTOBUF_C_LABEL_OPTIONAL,
5452
    PROTOBUF_C_TYPE_STRING,
5453
    0,   /* quantifier_offset */
5454
    offsetof(Foo__TestRequiredFieldsBitmap, field86),
5455
    NULL,
5456
    NULL,
5457
    0,             /* flags */
5458
    0,NULL,NULL    /* reserved1,reserved2, etc */
5459
  },
5460
  {
5461
    "field87",
5462
    87,
5463
    PROTOBUF_C_LABEL_OPTIONAL,
5464
    PROTOBUF_C_TYPE_STRING,
5465
    0,   /* quantifier_offset */
5466
    offsetof(Foo__TestRequiredFieldsBitmap, field87),
5467
    NULL,
5468
    NULL,
5469
    0,             /* flags */
5470
    0,NULL,NULL    /* reserved1,reserved2, etc */
5471
  },
5472
  {
5473
    "field88",
5474
    88,
5475
    PROTOBUF_C_LABEL_OPTIONAL,
5476
    PROTOBUF_C_TYPE_STRING,
5477
    0,   /* quantifier_offset */
5478
    offsetof(Foo__TestRequiredFieldsBitmap, field88),
5479
    NULL,
5480
    NULL,
5481
    0,             /* flags */
5482
    0,NULL,NULL    /* reserved1,reserved2, etc */
5483
  },
5484
  {
5485
    "field89",
5486
    89,
5487
    PROTOBUF_C_LABEL_OPTIONAL,
5488
    PROTOBUF_C_TYPE_STRING,
5489
    0,   /* quantifier_offset */
5490
    offsetof(Foo__TestRequiredFieldsBitmap, field89),
5491
    NULL,
5492
    NULL,
5493
    0,             /* flags */
5494
    0,NULL,NULL    /* reserved1,reserved2, etc */
5495
  },
5496
  {
5497
    "field90",
5498
    90,
5499
    PROTOBUF_C_LABEL_OPTIONAL,
5500
    PROTOBUF_C_TYPE_STRING,
5501
    0,   /* quantifier_offset */
5502
    offsetof(Foo__TestRequiredFieldsBitmap, field90),
5503
    NULL,
5504
    NULL,
5505
    0,             /* flags */
5506
    0,NULL,NULL    /* reserved1,reserved2, etc */
5507
  },
5508
  {
5509
    "field91",
5510
    91,
5511
    PROTOBUF_C_LABEL_OPTIONAL,
5512
    PROTOBUF_C_TYPE_STRING,
5513
    0,   /* quantifier_offset */
5514
    offsetof(Foo__TestRequiredFieldsBitmap, field91),
5515
    NULL,
5516
    NULL,
5517
    0,             /* flags */
5518
    0,NULL,NULL    /* reserved1,reserved2, etc */
5519
  },
5520
  {
5521
    "field92",
5522
    92,
5523
    PROTOBUF_C_LABEL_OPTIONAL,
5524
    PROTOBUF_C_TYPE_STRING,
5525
    0,   /* quantifier_offset */
5526
    offsetof(Foo__TestRequiredFieldsBitmap, field92),
5527
    NULL,
5528
    NULL,
5529
    0,             /* flags */
5530
    0,NULL,NULL    /* reserved1,reserved2, etc */
5531
  },
5532
  {
5533
    "field93",
5534
    93,
5535
    PROTOBUF_C_LABEL_OPTIONAL,
5536
    PROTOBUF_C_TYPE_STRING,
5537
    0,   /* quantifier_offset */
5538
    offsetof(Foo__TestRequiredFieldsBitmap, field93),
5539
    NULL,
5540
    NULL,
5541
    0,             /* flags */
5542
    0,NULL,NULL    /* reserved1,reserved2, etc */
5543
  },
5544
  {
5545
    "field94",
5546
    94,
5547
    PROTOBUF_C_LABEL_OPTIONAL,
5548
    PROTOBUF_C_TYPE_STRING,
5549
    0,   /* quantifier_offset */
5550
    offsetof(Foo__TestRequiredFieldsBitmap, field94),
5551
    NULL,
5552
    NULL,
5553
    0,             /* flags */
5554
    0,NULL,NULL    /* reserved1,reserved2, etc */
5555
  },
5556
  {
5557
    "field95",
5558
    95,
5559
    PROTOBUF_C_LABEL_OPTIONAL,
5560
    PROTOBUF_C_TYPE_STRING,
5561
    0,   /* quantifier_offset */
5562
    offsetof(Foo__TestRequiredFieldsBitmap, field95),
5563
    NULL,
5564
    NULL,
5565
    0,             /* flags */
5566
    0,NULL,NULL    /* reserved1,reserved2, etc */
5567
  },
5568
  {
5569
    "field96",
5570
    96,
5571
    PROTOBUF_C_LABEL_OPTIONAL,
5572
    PROTOBUF_C_TYPE_STRING,
5573
    0,   /* quantifier_offset */
5574
    offsetof(Foo__TestRequiredFieldsBitmap, field96),
5575
    NULL,
5576
    NULL,
5577
    0,             /* flags */
5578
    0,NULL,NULL    /* reserved1,reserved2, etc */
5579
  },
5580
  {
5581
    "field97",
5582
    97,
5583
    PROTOBUF_C_LABEL_OPTIONAL,
5584
    PROTOBUF_C_TYPE_STRING,
5585
    0,   /* quantifier_offset */
5586
    offsetof(Foo__TestRequiredFieldsBitmap, field97),
5587
    NULL,
5588
    NULL,
5589
    0,             /* flags */
5590
    0,NULL,NULL    /* reserved1,reserved2, etc */
5591
  },
5592
  {
5593
    "field98",
5594
    98,
5595
    PROTOBUF_C_LABEL_OPTIONAL,
5596
    PROTOBUF_C_TYPE_STRING,
5597
    0,   /* quantifier_offset */
5598
    offsetof(Foo__TestRequiredFieldsBitmap, field98),
5599
    NULL,
5600
    NULL,
5601
    0,             /* flags */
5602
    0,NULL,NULL    /* reserved1,reserved2, etc */
5603
  },
5604
  {
5605
    "field99",
5606
    99,
5607
    PROTOBUF_C_LABEL_OPTIONAL,
5608
    PROTOBUF_C_TYPE_STRING,
5609
    0,   /* quantifier_offset */
5610
    offsetof(Foo__TestRequiredFieldsBitmap, field99),
5611
    NULL,
5612
    NULL,
5613
    0,             /* flags */
5614
    0,NULL,NULL    /* reserved1,reserved2, etc */
5615
  },
5616
  {
5617
    "field100",
5618
    100,
5619
    PROTOBUF_C_LABEL_OPTIONAL,
5620
    PROTOBUF_C_TYPE_STRING,
5621
    0,   /* quantifier_offset */
5622
    offsetof(Foo__TestRequiredFieldsBitmap, field100),
5623
    NULL,
5624
    NULL,
5625
    0,             /* flags */
5626
    0,NULL,NULL    /* reserved1,reserved2, etc */
5627
  },
5628
  {
5629
    "field101",
5630
    101,
5631
    PROTOBUF_C_LABEL_OPTIONAL,
5632
    PROTOBUF_C_TYPE_STRING,
5633
    0,   /* quantifier_offset */
5634
    offsetof(Foo__TestRequiredFieldsBitmap, field101),
5635
    NULL,
5636
    NULL,
5637
    0,             /* flags */
5638
    0,NULL,NULL    /* reserved1,reserved2, etc */
5639
  },
5640
  {
5641
    "field102",
5642
    102,
5643
    PROTOBUF_C_LABEL_OPTIONAL,
5644
    PROTOBUF_C_TYPE_STRING,
5645
    0,   /* quantifier_offset */
5646
    offsetof(Foo__TestRequiredFieldsBitmap, field102),
5647
    NULL,
5648
    NULL,
5649
    0,             /* flags */
5650
    0,NULL,NULL    /* reserved1,reserved2, etc */
5651
  },
5652
  {
5653
    "field103",
5654
    103,
5655
    PROTOBUF_C_LABEL_OPTIONAL,
5656
    PROTOBUF_C_TYPE_STRING,
5657
    0,   /* quantifier_offset */
5658
    offsetof(Foo__TestRequiredFieldsBitmap, field103),
5659
    NULL,
5660
    NULL,
5661
    0,             /* flags */
5662
    0,NULL,NULL    /* reserved1,reserved2, etc */
5663
  },
5664
  {
5665
    "field104",
5666
    104,
5667
    PROTOBUF_C_LABEL_OPTIONAL,
5668
    PROTOBUF_C_TYPE_STRING,
5669
    0,   /* quantifier_offset */
5670
    offsetof(Foo__TestRequiredFieldsBitmap, field104),
5671
    NULL,
5672
    NULL,
5673
    0,             /* flags */
5674
    0,NULL,NULL    /* reserved1,reserved2, etc */
5675
  },
5676
  {
5677
    "field105",
5678
    105,
5679
    PROTOBUF_C_LABEL_OPTIONAL,
5680
    PROTOBUF_C_TYPE_STRING,
5681
    0,   /* quantifier_offset */
5682
    offsetof(Foo__TestRequiredFieldsBitmap, field105),
5683
    NULL,
5684
    NULL,
5685
    0,             /* flags */
5686
    0,NULL,NULL    /* reserved1,reserved2, etc */
5687
  },
5688
  {
5689
    "field106",
5690
    106,
5691
    PROTOBUF_C_LABEL_OPTIONAL,
5692
    PROTOBUF_C_TYPE_STRING,
5693
    0,   /* quantifier_offset */
5694
    offsetof(Foo__TestRequiredFieldsBitmap, field106),
5695
    NULL,
5696
    NULL,
5697
    0,             /* flags */
5698
    0,NULL,NULL    /* reserved1,reserved2, etc */
5699
  },
5700
  {
5701
    "field107",
5702
    107,
5703
    PROTOBUF_C_LABEL_OPTIONAL,
5704
    PROTOBUF_C_TYPE_STRING,
5705
    0,   /* quantifier_offset */
5706
    offsetof(Foo__TestRequiredFieldsBitmap, field107),
5707
    NULL,
5708
    NULL,
5709
    0,             /* flags */
5710
    0,NULL,NULL    /* reserved1,reserved2, etc */
5711
  },
5712
  {
5713
    "field108",
5714
    108,
5715
    PROTOBUF_C_LABEL_OPTIONAL,
5716
    PROTOBUF_C_TYPE_STRING,
5717
    0,   /* quantifier_offset */
5718
    offsetof(Foo__TestRequiredFieldsBitmap, field108),
5719
    NULL,
5720
    NULL,
5721
    0,             /* flags */
5722
    0,NULL,NULL    /* reserved1,reserved2, etc */
5723
  },
5724
  {
5725
    "field109",
5726
    109,
5727
    PROTOBUF_C_LABEL_OPTIONAL,
5728
    PROTOBUF_C_TYPE_STRING,
5729
    0,   /* quantifier_offset */
5730
    offsetof(Foo__TestRequiredFieldsBitmap, field109),
5731
    NULL,
5732
    NULL,
5733
    0,             /* flags */
5734
    0,NULL,NULL    /* reserved1,reserved2, etc */
5735
  },
5736
  {
5737
    "field110",
5738
    110,
5739
    PROTOBUF_C_LABEL_OPTIONAL,
5740
    PROTOBUF_C_TYPE_STRING,
5741
    0,   /* quantifier_offset */
5742
    offsetof(Foo__TestRequiredFieldsBitmap, field110),
5743
    NULL,
5744
    NULL,
5745
    0,             /* flags */
5746
    0,NULL,NULL    /* reserved1,reserved2, etc */
5747
  },
5748
  {
5749
    "field111",
5750
    111,
5751
    PROTOBUF_C_LABEL_OPTIONAL,
5752
    PROTOBUF_C_TYPE_STRING,
5753
    0,   /* quantifier_offset */
5754
    offsetof(Foo__TestRequiredFieldsBitmap, field111),
5755
    NULL,
5756
    NULL,
5757
    0,             /* flags */
5758
    0,NULL,NULL    /* reserved1,reserved2, etc */
5759
  },
5760
  {
5761
    "field112",
5762
    112,
5763
    PROTOBUF_C_LABEL_OPTIONAL,
5764
    PROTOBUF_C_TYPE_STRING,
5765
    0,   /* quantifier_offset */
5766
    offsetof(Foo__TestRequiredFieldsBitmap, field112),
5767
    NULL,
5768
    NULL,
5769
    0,             /* flags */
5770
    0,NULL,NULL    /* reserved1,reserved2, etc */
5771
  },
5772
  {
5773
    "field113",
5774
    113,
5775
    PROTOBUF_C_LABEL_OPTIONAL,
5776
    PROTOBUF_C_TYPE_STRING,
5777
    0,   /* quantifier_offset */
5778
    offsetof(Foo__TestRequiredFieldsBitmap, field113),
5779
    NULL,
5780
    NULL,
5781
    0,             /* flags */
5782
    0,NULL,NULL    /* reserved1,reserved2, etc */
5783
  },
5784
  {
5785
    "field114",
5786
    114,
5787
    PROTOBUF_C_LABEL_OPTIONAL,
5788
    PROTOBUF_C_TYPE_STRING,
5789
    0,   /* quantifier_offset */
5790
    offsetof(Foo__TestRequiredFieldsBitmap, field114),
5791
    NULL,
5792
    NULL,
5793
    0,             /* flags */
5794
    0,NULL,NULL    /* reserved1,reserved2, etc */
5795
  },
5796
  {
5797
    "field115",
5798
    115,
5799
    PROTOBUF_C_LABEL_OPTIONAL,
5800
    PROTOBUF_C_TYPE_STRING,
5801
    0,   /* quantifier_offset */
5802
    offsetof(Foo__TestRequiredFieldsBitmap, field115),
5803
    NULL,
5804
    NULL,
5805
    0,             /* flags */
5806
    0,NULL,NULL    /* reserved1,reserved2, etc */
5807
  },
5808
  {
5809
    "field116",
5810
    116,
5811
    PROTOBUF_C_LABEL_OPTIONAL,
5812
    PROTOBUF_C_TYPE_STRING,
5813
    0,   /* quantifier_offset */
5814
    offsetof(Foo__TestRequiredFieldsBitmap, field116),
5815
    NULL,
5816
    NULL,
5817
    0,             /* flags */
5818
    0,NULL,NULL    /* reserved1,reserved2, etc */
5819
  },
5820
  {
5821
    "field117",
5822
    117,
5823
    PROTOBUF_C_LABEL_OPTIONAL,
5824
    PROTOBUF_C_TYPE_STRING,
5825
    0,   /* quantifier_offset */
5826
    offsetof(Foo__TestRequiredFieldsBitmap, field117),
5827
    NULL,
5828
    NULL,
5829
    0,             /* flags */
5830
    0,NULL,NULL    /* reserved1,reserved2, etc */
5831
  },
5832
  {
5833
    "field118",
5834
    118,
5835
    PROTOBUF_C_LABEL_OPTIONAL,
5836
    PROTOBUF_C_TYPE_STRING,
5837
    0,   /* quantifier_offset */
5838
    offsetof(Foo__TestRequiredFieldsBitmap, field118),
5839
    NULL,
5840
    NULL,
5841
    0,             /* flags */
5842
    0,NULL,NULL    /* reserved1,reserved2, etc */
5843
  },
5844
  {
5845
    "field119",
5846
    119,
5847
    PROTOBUF_C_LABEL_OPTIONAL,
5848
    PROTOBUF_C_TYPE_STRING,
5849
    0,   /* quantifier_offset */
5850
    offsetof(Foo__TestRequiredFieldsBitmap, field119),
5851
    NULL,
5852
    NULL,
5853
    0,             /* flags */
5854
    0,NULL,NULL    /* reserved1,reserved2, etc */
5855
  },
5856
  {
5857
    "field120",
5858
    120,
5859
    PROTOBUF_C_LABEL_OPTIONAL,
5860
    PROTOBUF_C_TYPE_STRING,
5861
    0,   /* quantifier_offset */
5862
    offsetof(Foo__TestRequiredFieldsBitmap, field120),
5863
    NULL,
5864
    NULL,
5865
    0,             /* flags */
5866
    0,NULL,NULL    /* reserved1,reserved2, etc */
5867
  },
5868
  {
5869
    "field121",
5870
    121,
5871
    PROTOBUF_C_LABEL_OPTIONAL,
5872
    PROTOBUF_C_TYPE_STRING,
5873
    0,   /* quantifier_offset */
5874
    offsetof(Foo__TestRequiredFieldsBitmap, field121),
5875
    NULL,
5876
    NULL,
5877
    0,             /* flags */
5878
    0,NULL,NULL    /* reserved1,reserved2, etc */
5879
  },
5880
  {
5881
    "field122",
5882
    122,
5883
    PROTOBUF_C_LABEL_OPTIONAL,
5884
    PROTOBUF_C_TYPE_STRING,
5885
    0,   /* quantifier_offset */
5886
    offsetof(Foo__TestRequiredFieldsBitmap, field122),
5887
    NULL,
5888
    NULL,
5889
    0,             /* flags */
5890
    0,NULL,NULL    /* reserved1,reserved2, etc */
5891
  },
5892
  {
5893
    "field123",
5894
    123,
5895
    PROTOBUF_C_LABEL_OPTIONAL,
5896
    PROTOBUF_C_TYPE_STRING,
5897
    0,   /* quantifier_offset */
5898
    offsetof(Foo__TestRequiredFieldsBitmap, field123),
5899
    NULL,
5900
    NULL,
5901
    0,             /* flags */
5902
    0,NULL,NULL    /* reserved1,reserved2, etc */
5903
  },
5904
  {
5905
    "field124",
5906
    124,
5907
    PROTOBUF_C_LABEL_OPTIONAL,
5908
    PROTOBUF_C_TYPE_STRING,
5909
    0,   /* quantifier_offset */
5910
    offsetof(Foo__TestRequiredFieldsBitmap, field124),
5911
    NULL,
5912
    NULL,
5913
    0,             /* flags */
5914
    0,NULL,NULL    /* reserved1,reserved2, etc */
5915
  },
5916
  {
5917
    "field125",
5918
    125,
5919
    PROTOBUF_C_LABEL_OPTIONAL,
5920
    PROTOBUF_C_TYPE_STRING,
5921
    0,   /* quantifier_offset */
5922
    offsetof(Foo__TestRequiredFieldsBitmap, field125),
5923
    NULL,
5924
    NULL,
5925
    0,             /* flags */
5926
    0,NULL,NULL    /* reserved1,reserved2, etc */
5927
  },
5928
  {
5929
    "field126",
5930
    126,
5931
    PROTOBUF_C_LABEL_OPTIONAL,
5932
    PROTOBUF_C_TYPE_STRING,
5933
    0,   /* quantifier_offset */
5934
    offsetof(Foo__TestRequiredFieldsBitmap, field126),
5935
    NULL,
5936
    NULL,
5937
    0,             /* flags */
5938
    0,NULL,NULL    /* reserved1,reserved2, etc */
5939
  },
5940
  {
5941
    "field127",
5942
    127,
5943
    PROTOBUF_C_LABEL_OPTIONAL,
5944
    PROTOBUF_C_TYPE_STRING,
5945
    0,   /* quantifier_offset */
5946
    offsetof(Foo__TestRequiredFieldsBitmap, field127),
5947
    NULL,
5948
    NULL,
5949
    0,             /* flags */
5950
    0,NULL,NULL    /* reserved1,reserved2, etc */
5951
  },
5952
  {
5953
    "field128",
5954
    128,
5955
    PROTOBUF_C_LABEL_OPTIONAL,
5956
    PROTOBUF_C_TYPE_STRING,
5957
    0,   /* quantifier_offset */
5958
    offsetof(Foo__TestRequiredFieldsBitmap, field128),
5959
    NULL,
5960
    NULL,
5961
    0,             /* flags */
5962
    0,NULL,NULL    /* reserved1,reserved2, etc */
5963
  },
5964
  {
5965
    "field129",
5966
    129,
5967
    PROTOBUF_C_LABEL_REQUIRED,
5968
    PROTOBUF_C_TYPE_STRING,
5969
    0,   /* quantifier_offset */
5970
    offsetof(Foo__TestRequiredFieldsBitmap, field129),
5971
    NULL,
5972
    NULL,
5973
    0,             /* flags */
5974
    0,NULL,NULL    /* reserved1,reserved2, etc */
5975
  },
5976
};
5977
static const unsigned foo__test_required_fields_bitmap__field_indices_by_name[] = {
5978
  0,   /* field[0] = field1 */
5979
  9,   /* field[9] = field10 */
5980
  99,   /* field[99] = field100 */
5981
  100,   /* field[100] = field101 */
5982
  101,   /* field[101] = field102 */
5983
  102,   /* field[102] = field103 */
5984
  103,   /* field[103] = field104 */
5985
  104,   /* field[104] = field105 */
5986
  105,   /* field[105] = field106 */
5987
  106,   /* field[106] = field107 */
5988
  107,   /* field[107] = field108 */
5989
  108,   /* field[108] = field109 */
5990
  10,   /* field[10] = field11 */
5991
  109,   /* field[109] = field110 */
5992
  110,   /* field[110] = field111 */
5993
  111,   /* field[111] = field112 */
5994
  112,   /* field[112] = field113 */
5995
  113,   /* field[113] = field114 */
5996
  114,   /* field[114] = field115 */
5997
  115,   /* field[115] = field116 */
5998
  116,   /* field[116] = field117 */
5999
  117,   /* field[117] = field118 */
6000
  118,   /* field[118] = field119 */
6001
  11,   /* field[11] = field12 */
6002
  119,   /* field[119] = field120 */
6003
  120,   /* field[120] = field121 */
6004
  121,   /* field[121] = field122 */
6005
  122,   /* field[122] = field123 */
6006
  123,   /* field[123] = field124 */
6007
  124,   /* field[124] = field125 */
6008
  125,   /* field[125] = field126 */
6009
  126,   /* field[126] = field127 */
6010
  127,   /* field[127] = field128 */
6011
  128,   /* field[128] = field129 */
6012
  12,   /* field[12] = field13 */
6013
  13,   /* field[13] = field14 */
6014
  14,   /* field[14] = field15 */
6015
  15,   /* field[15] = field16 */
6016
  16,   /* field[16] = field17 */
6017
  17,   /* field[17] = field18 */
6018
  18,   /* field[18] = field19 */
6019
  1,   /* field[1] = field2 */
6020
  19,   /* field[19] = field20 */
6021
  20,   /* field[20] = field21 */
6022
  21,   /* field[21] = field22 */
6023
  22,   /* field[22] = field23 */
6024
  23,   /* field[23] = field24 */
6025
  24,   /* field[24] = field25 */
6026
  25,   /* field[25] = field26 */
6027
  26,   /* field[26] = field27 */
6028
  27,   /* field[27] = field28 */
6029
  28,   /* field[28] = field29 */
6030
  2,   /* field[2] = field3 */
6031
  29,   /* field[29] = field30 */
6032
  30,   /* field[30] = field31 */
6033
  31,   /* field[31] = field32 */
6034
  32,   /* field[32] = field33 */
6035
  33,   /* field[33] = field34 */
6036
  34,   /* field[34] = field35 */
6037
  35,   /* field[35] = field36 */
6038
  36,   /* field[36] = field37 */
6039
  37,   /* field[37] = field38 */
6040
  38,   /* field[38] = field39 */
6041
  3,   /* field[3] = field4 */
6042
  39,   /* field[39] = field40 */
6043
  40,   /* field[40] = field41 */
6044
  41,   /* field[41] = field42 */
6045
  42,   /* field[42] = field43 */
6046
  43,   /* field[43] = field44 */
6047
  44,   /* field[44] = field45 */
6048
  45,   /* field[45] = field46 */
6049
  46,   /* field[46] = field47 */
6050
  47,   /* field[47] = field48 */
6051
  48,   /* field[48] = field49 */
6052
  4,   /* field[4] = field5 */
6053
  49,   /* field[49] = field50 */
6054
  50,   /* field[50] = field51 */
6055
  51,   /* field[51] = field52 */
6056
  52,   /* field[52] = field53 */
6057
  53,   /* field[53] = field54 */
6058
  54,   /* field[54] = field55 */
6059
  55,   /* field[55] = field56 */
6060
  56,   /* field[56] = field57 */
6061
  57,   /* field[57] = field58 */
6062
  58,   /* field[58] = field59 */
6063
  5,   /* field[5] = field6 */
6064
  59,   /* field[59] = field60 */
6065
  60,   /* field[60] = field61 */
6066
  61,   /* field[61] = field62 */
6067
  62,   /* field[62] = field63 */
6068
  63,   /* field[63] = field64 */
6069
  64,   /* field[64] = field65 */
6070
  65,   /* field[65] = field66 */
6071
  66,   /* field[66] = field67 */
6072
  67,   /* field[67] = field68 */
6073
  68,   /* field[68] = field69 */
6074
  6,   /* field[6] = field7 */
6075
  69,   /* field[69] = field70 */
6076
  70,   /* field[70] = field71 */
6077
  71,   /* field[71] = field72 */
6078
  72,   /* field[72] = field73 */
6079
  73,   /* field[73] = field74 */
6080
  74,   /* field[74] = field75 */
6081
  75,   /* field[75] = field76 */
6082
  76,   /* field[76] = field77 */
6083
  77,   /* field[77] = field78 */
6084
  78,   /* field[78] = field79 */
6085
  7,   /* field[7] = field8 */
6086
  79,   /* field[79] = field80 */
6087
  80,   /* field[80] = field81 */
6088
  81,   /* field[81] = field82 */
6089
  82,   /* field[82] = field83 */
6090
  83,   /* field[83] = field84 */
6091
  84,   /* field[84] = field85 */
6092
  85,   /* field[85] = field86 */
6093
  86,   /* field[86] = field87 */
6094
  87,   /* field[87] = field88 */
6095
  88,   /* field[88] = field89 */
6096
  8,   /* field[8] = field9 */
6097
  89,   /* field[89] = field90 */
6098
  90,   /* field[90] = field91 */
6099
  91,   /* field[91] = field92 */
6100
  92,   /* field[92] = field93 */
6101
  93,   /* field[93] = field94 */
6102
  94,   /* field[94] = field95 */
6103
  95,   /* field[95] = field96 */
6104
  96,   /* field[96] = field97 */
6105
  97,   /* field[97] = field98 */
6106
  98,   /* field[98] = field99 */
6107
};
6108
static const ProtobufCIntRange foo__test_required_fields_bitmap__number_ranges[1 + 1] =
6109
{
6110
  { 1, 0 },
6111
  { 0, 129 }
6112
};
6113
const ProtobufCMessageDescriptor foo__test_required_fields_bitmap__descriptor =
6114
{
6115
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6116
  "foo.TestRequiredFieldsBitmap",
6117
  "TestRequiredFieldsBitmap",
6118
  "Foo__TestRequiredFieldsBitmap",
6119
  "foo",
6120
  sizeof(Foo__TestRequiredFieldsBitmap),
6121
  129,
6122
  foo__test_required_fields_bitmap__field_descriptors,
6123
  foo__test_required_fields_bitmap__field_indices_by_name,
6124
  1,  foo__test_required_fields_bitmap__number_ranges,
6125
  (ProtobufCMessageInit) foo__test_required_fields_bitmap__init,
6126
  NULL,NULL,NULL    /* reserved[123] */
6127
};
6128
static const ProtobufCFieldDescriptor foo__test_field_flags__field_descriptors[6] =
6129
{
6130
  {
6131
    "no_flags1",
6132
    1,
6133
    PROTOBUF_C_LABEL_OPTIONAL,
6134
    PROTOBUF_C_TYPE_INT32,
6135
    offsetof(Foo__TestFieldFlags, has_no_flags1),
6136
    offsetof(Foo__TestFieldFlags, no_flags1),
6137
    NULL,
6138
    NULL,
6139
    0,             /* flags */
6140
    0,NULL,NULL    /* reserved1,reserved2, etc */
6141
  },
6142
  {
6143
    "no_flags2",
6144
    2,
6145
    PROTOBUF_C_LABEL_REQUIRED,
6146
    PROTOBUF_C_TYPE_INT32,
6147
    0,   /* quantifier_offset */
6148
    offsetof(Foo__TestFieldFlags, no_flags2),
6149
    NULL,
6150
    NULL,
6151
    0,             /* flags */
6152
    0,NULL,NULL    /* reserved1,reserved2, etc */
6153
  },
6154
  {
6155
    "no_flags3",
6156
    3,
6157
    PROTOBUF_C_LABEL_REPEATED,
6158
    PROTOBUF_C_TYPE_INT32,
6159
    offsetof(Foo__TestFieldFlags, n_no_flags3),
6160
    offsetof(Foo__TestFieldFlags, no_flags3),
6161
    NULL,
6162
    NULL,
6163
    0,             /* flags */
6164
    0,NULL,NULL    /* reserved1,reserved2, etc */
6165
  },
6166
  {
6167
    "packed",
6168
    4,
6169
    PROTOBUF_C_LABEL_REPEATED,
6170
    PROTOBUF_C_TYPE_INT32,
6171
    offsetof(Foo__TestFieldFlags, n_packed),
6172
    offsetof(Foo__TestFieldFlags, packed),
6173
    NULL,
6174
    NULL,
6175
    PROTOBUF_C_FIELD_FLAG_PACKED,             /* flags */
6176
    0,NULL,NULL    /* reserved1,reserved2, etc */
6177
  },
6178
  {
6179
    "packed_deprecated",
6180
    5,
6181
    PROTOBUF_C_LABEL_REPEATED,
6182
    PROTOBUF_C_TYPE_INT32,
6183
    offsetof(Foo__TestFieldFlags, n_packed_deprecated),
6184
    offsetof(Foo__TestFieldFlags, packed_deprecated),
6185
    NULL,
6186
    NULL,
6187
    PROTOBUF_C_FIELD_FLAG_PACKED | PROTOBUF_C_FIELD_FLAG_DEPRECATED,             /* flags */
6188
    0,NULL,NULL    /* reserved1,reserved2, etc */
6189
  },
6190
  {
6191
    "deprecated",
6192
    6,
6193
    PROTOBUF_C_LABEL_REPEATED,
6194
    PROTOBUF_C_TYPE_INT32,
6195
    offsetof(Foo__TestFieldFlags, n_deprecated),
6196
    offsetof(Foo__TestFieldFlags, deprecated),
6197
    NULL,
6198
    NULL,
6199
    PROTOBUF_C_FIELD_FLAG_DEPRECATED,             /* flags */
6200
    0,NULL,NULL    /* reserved1,reserved2, etc */
6201
  },
6202
};
6203
static const unsigned foo__test_field_flags__field_indices_by_name[] = {
6204
  5,   /* field[5] = deprecated */
6205
  0,   /* field[0] = no_flags1 */
6206
  1,   /* field[1] = no_flags2 */
6207
  2,   /* field[2] = no_flags3 */
6208
  3,   /* field[3] = packed */
6209
  4,   /* field[4] = packed_deprecated */
6210
};
6211
static const ProtobufCIntRange foo__test_field_flags__number_ranges[1 + 1] =
6212
{
6213
  { 1, 0 },
6214
  { 0, 6 }
6215
};
6216
const ProtobufCMessageDescriptor foo__test_field_flags__descriptor =
6217
{
6218
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6219
  "foo.TestFieldFlags",
6220
  "TestFieldFlags",
6221
  "Foo__TestFieldFlags",
6222
  "foo",
6223
  sizeof(Foo__TestFieldFlags),
6224
  6,
6225
  foo__test_field_flags__field_descriptors,
6226
  foo__test_field_flags__field_indices_by_name,
6227
  1,  foo__test_field_flags__number_ranges,
6228
  (ProtobufCMessageInit) foo__test_field_flags__init,
6229
  NULL,NULL,NULL    /* reserved[123] */
6230
};
6231
static const ProtobufCFieldDescriptor foo__test_message_check__sub_message__field_descriptors[1] =
6232
{
6233
  {
6234
    "str",
6235
    1,
6236
    PROTOBUF_C_LABEL_REQUIRED,
6237
    PROTOBUF_C_TYPE_STRING,
6238
    0,   /* quantifier_offset */
6239
    offsetof(Foo__TestMessageCheck__SubMessage, str),
6240
    NULL,
6241
    NULL,
6242
    0,             /* flags */
6243
    0,NULL,NULL    /* reserved1,reserved2, etc */
6244
  },
6245
};
6246
static const unsigned foo__test_message_check__sub_message__field_indices_by_name[] = {
6247
  0,   /* field[0] = str */
6248
};
6249
static const ProtobufCIntRange foo__test_message_check__sub_message__number_ranges[1 + 1] =
6250
{
6251
  { 1, 0 },
6252
  { 0, 1 }
6253
};
6254
const ProtobufCMessageDescriptor foo__test_message_check__sub_message__descriptor =
6255
{
6256
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6257
  "foo.TestMessageCheck.SubMessage",
6258
  "SubMessage",
6259
  "Foo__TestMessageCheck__SubMessage",
6260
  "foo",
6261
  sizeof(Foo__TestMessageCheck__SubMessage),
6262
  1,
6263
  foo__test_message_check__sub_message__field_descriptors,
6264
  foo__test_message_check__sub_message__field_indices_by_name,
6265
  1,  foo__test_message_check__sub_message__number_ranges,
6266
  (ProtobufCMessageInit) foo__test_message_check__sub_message__init,
6267
  NULL,NULL,NULL    /* reserved[123] */
6268
};
6269
static const ProtobufCFieldDescriptor foo__test_message_check__field_descriptors[9] =
6270
{
6271
  {
6272
    "required_msg",
6273
    1,
6274
    PROTOBUF_C_LABEL_REQUIRED,
6275
    PROTOBUF_C_TYPE_MESSAGE,
6276
    0,   /* quantifier_offset */
6277
    offsetof(Foo__TestMessageCheck, required_msg),
6278
    &foo__test_message_check__sub_message__descriptor,
6279
    NULL,
6280
    0,             /* flags */
6281
    0,NULL,NULL    /* reserved1,reserved2, etc */
6282
  },
6283
  {
6284
    "repeated_msg",
6285
    2,
6286
    PROTOBUF_C_LABEL_REPEATED,
6287
    PROTOBUF_C_TYPE_MESSAGE,
6288
    offsetof(Foo__TestMessageCheck, n_repeated_msg),
6289
    offsetof(Foo__TestMessageCheck, repeated_msg),
6290
    &foo__test_message_check__sub_message__descriptor,
6291
    NULL,
6292
    0,             /* flags */
6293
    0,NULL,NULL    /* reserved1,reserved2, etc */
6294
  },
6295
  {
6296
    "optional_msg",
6297
    3,
6298
    PROTOBUF_C_LABEL_OPTIONAL,
6299
    PROTOBUF_C_TYPE_MESSAGE,
6300
    0,   /* quantifier_offset */
6301
    offsetof(Foo__TestMessageCheck, optional_msg),
6302
    &foo__test_message_check__sub_message__descriptor,
6303
    NULL,
6304
    0,             /* flags */
6305
    0,NULL,NULL    /* reserved1,reserved2, etc */
6306
  },
6307
  {
6308
    "required_string",
6309
    4,
6310
    PROTOBUF_C_LABEL_REQUIRED,
6311
    PROTOBUF_C_TYPE_STRING,
6312
    0,   /* quantifier_offset */
6313
    offsetof(Foo__TestMessageCheck, required_string),
6314
    NULL,
6315
    NULL,
6316
    0,             /* flags */
6317
    0,NULL,NULL    /* reserved1,reserved2, etc */
6318
  },
6319
  {
6320
    "repeated_string",
6321
    5,
6322
    PROTOBUF_C_LABEL_REPEATED,
6323
    PROTOBUF_C_TYPE_STRING,
6324
    offsetof(Foo__TestMessageCheck, n_repeated_string),
6325
    offsetof(Foo__TestMessageCheck, repeated_string),
6326
    NULL,
6327
    NULL,
6328
    0,             /* flags */
6329
    0,NULL,NULL    /* reserved1,reserved2, etc */
6330
  },
6331
  {
6332
    "optional_string",
6333
    6,
6334
    PROTOBUF_C_LABEL_OPTIONAL,
6335
    PROTOBUF_C_TYPE_STRING,
6336
    0,   /* quantifier_offset */
6337
    offsetof(Foo__TestMessageCheck, optional_string),
6338
    NULL,
6339
    NULL,
6340
    0,             /* flags */
6341
    0,NULL,NULL    /* reserved1,reserved2, etc */
6342
  },
6343
  {
6344
    "required_bytes",
6345
    7,
6346
    PROTOBUF_C_LABEL_REQUIRED,
6347
    PROTOBUF_C_TYPE_BYTES,
6348
    0,   /* quantifier_offset */
6349
    offsetof(Foo__TestMessageCheck, required_bytes),
6350
    NULL,
6351
    NULL,
6352
    0,             /* flags */
6353
    0,NULL,NULL    /* reserved1,reserved2, etc */
6354
  },
6355
  {
6356
    "repeated_bytes",
6357
    8,
6358
    PROTOBUF_C_LABEL_REPEATED,
6359
    PROTOBUF_C_TYPE_BYTES,
6360
    offsetof(Foo__TestMessageCheck, n_repeated_bytes),
6361
    offsetof(Foo__TestMessageCheck, repeated_bytes),
6362
    NULL,
6363
    NULL,
6364
    0,             /* flags */
6365
    0,NULL,NULL    /* reserved1,reserved2, etc */
6366
  },
6367
  {
6368
    "optional_bytes",
6369
    9,
6370
    PROTOBUF_C_LABEL_OPTIONAL,
6371
    PROTOBUF_C_TYPE_BYTES,
6372
    offsetof(Foo__TestMessageCheck, has_optional_bytes),
6373
    offsetof(Foo__TestMessageCheck, optional_bytes),
6374
    NULL,
6375
    NULL,
6376
    0,             /* flags */
6377
    0,NULL,NULL    /* reserved1,reserved2, etc */
6378
  },
6379
};
6380
static const unsigned foo__test_message_check__field_indices_by_name[] = {
6381
  8,   /* field[8] = optional_bytes */
6382
  2,   /* field[2] = optional_msg */
6383
  5,   /* field[5] = optional_string */
6384
  7,   /* field[7] = repeated_bytes */
6385
  1,   /* field[1] = repeated_msg */
6386
  4,   /* field[4] = repeated_string */
6387
  6,   /* field[6] = required_bytes */
6388
  0,   /* field[0] = required_msg */
6389
  3,   /* field[3] = required_string */
6390
};
6391
static const ProtobufCIntRange foo__test_message_check__number_ranges[1 + 1] =
6392
{
6393
  { 1, 0 },
6394
  { 0, 9 }
6395
};
6396
const ProtobufCMessageDescriptor foo__test_message_check__descriptor =
6397
{
6398
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6399
  "foo.TestMessageCheck",
6400
  "TestMessageCheck",
6401
  "Foo__TestMessageCheck",
6402
  "foo",
6403
  sizeof(Foo__TestMessageCheck),
6404
  9,
6405
  foo__test_message_check__field_descriptors,
6406
  foo__test_message_check__field_indices_by_name,
6407
  1,  foo__test_message_check__number_ranges,
6408
  (ProtobufCMessageInit) foo__test_message_check__init,
6409
  NULL,NULL,NULL    /* reserved[123] */
6410
};
6411
static const ProtobufCFieldDescriptor foo__test_mess_sub_mess__field_descriptors[5] =
6412
{
6413
  {
6414
    "rep_mess",
6415
    1,
6416
    PROTOBUF_C_LABEL_REQUIRED,
6417
    PROTOBUF_C_TYPE_MESSAGE,
6418
    0,   /* quantifier_offset */
6419
    offsetof(Foo__TestMessSubMess, rep_mess),
6420
    &foo__test_mess__descriptor,
6421
    NULL,
6422
    0,             /* flags */
6423
    0,NULL,NULL    /* reserved1,reserved2, etc */
6424
  },
6425
  {
6426
    "opt_mess",
6427
    2,
6428
    PROTOBUF_C_LABEL_REQUIRED,
6429
    PROTOBUF_C_TYPE_MESSAGE,
6430
    0,   /* quantifier_offset */
6431
    offsetof(Foo__TestMessSubMess, opt_mess),
6432
    &foo__test_mess_optional__descriptor,
6433
    NULL,
6434
    0,             /* flags */
6435
    0,NULL,NULL    /* reserved1,reserved2, etc */
6436
  },
6437
  {
6438
    "oneof_mess",
6439
    3,
6440
    PROTOBUF_C_LABEL_REQUIRED,
6441
    PROTOBUF_C_TYPE_MESSAGE,
6442
    0,   /* quantifier_offset */
6443
    offsetof(Foo__TestMessSubMess, oneof_mess),
6444
    &foo__test_mess_oneof__descriptor,
6445
    NULL,
6446
    0,             /* flags */
6447
    0,NULL,NULL    /* reserved1,reserved2, etc */
6448
  },
6449
  {
6450
    "req_mess",
6451
    4,
6452
    PROTOBUF_C_LABEL_REQUIRED,
6453
    PROTOBUF_C_TYPE_MESSAGE,
6454
    0,   /* quantifier_offset */
6455
    offsetof(Foo__TestMessSubMess, req_mess),
6456
    &foo__sub_mess__descriptor,
6457
    NULL,
6458
    0,             /* flags */
6459
    0,NULL,NULL    /* reserved1,reserved2, etc */
6460
  },
6461
  {
6462
    "def_mess",
6463
    5,
6464
    PROTOBUF_C_LABEL_REQUIRED,
6465
    PROTOBUF_C_TYPE_MESSAGE,
6466
    0,   /* quantifier_offset */
6467
    offsetof(Foo__TestMessSubMess, def_mess),
6468
    &foo__default_optional_values__descriptor,
6469
    NULL,
6470
    0,             /* flags */
6471
    0,NULL,NULL    /* reserved1,reserved2, etc */
6472
  },
6473
};
6474
static const unsigned foo__test_mess_sub_mess__field_indices_by_name[] = {
6475
  4,   /* field[4] = def_mess */
6476
  2,   /* field[2] = oneof_mess */
6477
  1,   /* field[1] = opt_mess */
6478
  0,   /* field[0] = rep_mess */
6479
  3,   /* field[3] = req_mess */
6480
};
6481
static const ProtobufCIntRange foo__test_mess_sub_mess__number_ranges[1 + 1] =
6482
{
6483
  { 1, 0 },
6484
  { 0, 5 }
6485
};
6486
const ProtobufCMessageDescriptor foo__test_mess_sub_mess__descriptor =
6487
{
6488
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6489
  "foo.TestMessSubMess",
6490
  "TestMessSubMess",
6491
  "Foo__TestMessSubMess",
6492
  "foo",
6493
  sizeof(Foo__TestMessSubMess),
6494
  5,
6495
  foo__test_mess_sub_mess__field_descriptors,
6496
  foo__test_mess_sub_mess__field_indices_by_name,
6497
  1,  foo__test_mess_sub_mess__number_ranges,
6498
  (ProtobufCMessageInit) foo__test_mess_sub_mess__init,
6499
  NULL,NULL,NULL    /* reserved[123] */
6500
};
6501
static const ProtobufCEnumValue foo__test_enum_small__enum_values_by_number[3] =
6502
{
6503
  { "NEG_VALUE", "FOO__TEST_ENUM_SMALL__NEG_VALUE", -1 },
6504
  { "VALUE", "FOO__TEST_ENUM_SMALL__VALUE", 0 },
6505
  { "OTHER_VALUE", "FOO__TEST_ENUM_SMALL__OTHER_VALUE", 1 },
6506
};
6507
static const ProtobufCIntRange foo__test_enum_small__value_ranges[] = {
6508
{-1, 0},{0, 3}
6509
};
6510
static const ProtobufCEnumValueIndex foo__test_enum_small__enum_values_by_name[3] =
6511
{
6512
  { "NEG_VALUE", 0 },
6513
  { "OTHER_VALUE", 2 },
6514
  { "VALUE", 1 },
6515
};
6516
const ProtobufCEnumDescriptor foo__test_enum_small__descriptor =
6517
{
6518
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
6519
  "foo.TestEnumSmall",
6520
  "TestEnumSmall",
6521
  "Foo__TestEnumSmall",
6522
  "foo",
6523
  3,
6524
  foo__test_enum_small__enum_values_by_number,
6525
  3,
6526
  foo__test_enum_small__enum_values_by_name,
6527
  1,
6528
  foo__test_enum_small__value_ranges,
6529
  NULL,NULL,NULL,NULL   /* reserved[1234] */
6530
};
6531
static const ProtobufCEnumValue foo__test_enum__enum_values_by_number[12] =
6532
{
6533
  { "VALUENEG123456", "FOO__TEST_ENUM__VALUENEG123456", -123456 },
6534
  { "VALUENEG1", "FOO__TEST_ENUM__VALUENEG1", -1 },
6535
  { "VALUE0", "FOO__TEST_ENUM__VALUE0", 0 },
6536
  { "VALUE1", "FOO__TEST_ENUM__VALUE1", 1 },
6537
  { "VALUE127", "FOO__TEST_ENUM__VALUE127", 127 },
6538
  { "VALUE128", "FOO__TEST_ENUM__VALUE128", 128 },
6539
  { "VALUE16383", "FOO__TEST_ENUM__VALUE16383", 16383 },
6540
  { "VALUE16384", "FOO__TEST_ENUM__VALUE16384", 16384 },
6541
  { "VALUE2097151", "FOO__TEST_ENUM__VALUE2097151", 2097151 },
6542
  { "VALUE2097152", "FOO__TEST_ENUM__VALUE2097152", 2097152 },
6543
  { "VALUE268435455", "FOO__TEST_ENUM__VALUE268435455", 268435455 },
6544
  { "VALUE268435456", "FOO__TEST_ENUM__VALUE268435456", 268435456 },
6545
};
6546
static const ProtobufCIntRange foo__test_enum__value_ranges[] = {
6547
{-123456, 0},{-1, 1},{127, 4},{16383, 6},{2097151, 8},{268435455, 10},{0, 12}
6548
};
6549
static const ProtobufCEnumValueIndex foo__test_enum__enum_values_by_name[12] =
6550
{
6551
  { "VALUE0", 2 },
6552
  { "VALUE1", 3 },
6553
  { "VALUE127", 4 },
6554
  { "VALUE128", 5 },
6555
  { "VALUE16383", 6 },
6556
  { "VALUE16384", 7 },
6557
  { "VALUE2097151", 8 },
6558
  { "VALUE2097152", 9 },
6559
  { "VALUE268435455", 10 },
6560
  { "VALUE268435456", 11 },
6561
  { "VALUENEG1", 1 },
6562
  { "VALUENEG123456", 0 },
6563
};
6564
const ProtobufCEnumDescriptor foo__test_enum__descriptor =
6565
{
6566
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
6567
  "foo.TestEnum",
6568
  "TestEnum",
6569
  "Foo__TestEnum",
6570
  "foo",
6571
  12,
6572
  foo__test_enum__enum_values_by_number,
6573
  12,
6574
  foo__test_enum__enum_values_by_name,
6575
  6,
6576
  foo__test_enum__value_ranges,
6577
  NULL,NULL,NULL,NULL   /* reserved[1234] */
6578
};
6579
static const ProtobufCEnumValue foo__test_enum_dup_values__enum_values_by_number[4] =
6580
{
6581
  { "VALUE_A", "FOO__TEST_ENUM_DUP_VALUES__VALUE_A", 42 },
6582
  { "VALUE_D", "FOO__TEST_ENUM_DUP_VALUES__VALUE_D", 666 },
6583
  { "VALUE_F", "FOO__TEST_ENUM_DUP_VALUES__VALUE_F", 1000 },
6584
  { "VALUE_BB", "FOO__TEST_ENUM_DUP_VALUES__VALUE_BB", 1001 },
6585
};
6586
static const ProtobufCIntRange foo__test_enum_dup_values__value_ranges[] = {
6587
{42, 0},{666, 1},{1000, 2},{0, 4}
6588
};
6589
static const ProtobufCEnumValueIndex foo__test_enum_dup_values__enum_values_by_name[8] =
6590
{
6591
  { "VALUE_A", 0 },
6592
  { "VALUE_AA", 2 },
6593
  { "VALUE_B", 0 },
6594
  { "VALUE_BB", 3 },
6595
  { "VALUE_C", 0 },
6596
  { "VALUE_D", 1 },
6597
  { "VALUE_E", 1 },
6598
  { "VALUE_F", 2 },
6599
};
6600
const ProtobufCEnumDescriptor foo__test_enum_dup_values__descriptor =
6601
{
6602
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
6603
  "foo.TestEnumDupValues",
6604
  "TestEnumDupValues",
6605
  "Foo__TestEnumDupValues",
6606
  "foo",
6607
  4,
6608
  foo__test_enum_dup_values__enum_values_by_number,
6609
  8,
6610
  foo__test_enum_dup_values__enum_values_by_name,
6611
  3,
6612
  foo__test_enum_dup_values__value_ranges,
6613
  NULL,NULL,NULL,NULL   /* reserved[1234] */
6614
};