protobuf-generate 0.2.2 → 0.2.3
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/lib/protobuf/generate/language/c/c.erb +6 -2
- data/protobuf-generate.gemspec +1 -1
- data/test/c99/.gitignore +2 -0
- data/test/c99/alltypes.proto +82 -0
- data/test/c99/makefile +15 -0
- data/test/c99/test.c +242 -0
- data/test/c99/unit.h +25 -0
- metadata +13 -3
checksums.yaml
CHANGED
@@ -1,7 +1,7 @@
|
|
1
1
|
---
|
2
2
|
SHA1:
|
3
|
-
metadata.gz:
|
4
|
-
data.tar.gz:
|
3
|
+
metadata.gz: 1ea129566e0b2ad5679577e43688ced171c37a36
|
4
|
+
data.tar.gz: 828412c95f275bd17948cbe373f079e09156c960
|
5
5
|
SHA512:
|
6
|
-
metadata.gz:
|
7
|
-
data.tar.gz:
|
6
|
+
metadata.gz: 11392a315c361807a57116c3fc8e2c6707fe1e2c65b8009f82aeb48eda199d6b88cad8bf4ef67aada115ae8ca8af18bed37dc0416db512b4f7368bb9f1c40960
|
7
|
+
data.tar.gz: fd9553ff5266584892cf54a8cbdf4da1a040cb626c86df9d6afffa18e97760a6d04d7fa1dcba141b9595a59213ca6843a36b8af1f67795840e8497bd5141475b
|
@@ -239,6 +239,10 @@ static int read_raw_varint64(uint64_t *tag, const uint8_t *buffer, int offset) {
|
|
239
239
|
|
240
240
|
offset = read_raw_byte(&b, buffer, offset);
|
241
241
|
*tag |= (uint64_t)(b & 0x7f) << 56;
|
242
|
+
if ((b & 0x80) == 0) return offset;
|
243
|
+
|
244
|
+
offset = read_raw_byte(&b, buffer, offset);
|
245
|
+
*tag |= (uint64_t)(b & 0x7f) << 63;
|
242
246
|
return offset;
|
243
247
|
}
|
244
248
|
<% end %>
|
@@ -478,7 +482,7 @@ static int read_raw_varint64(uint64_t *tag, const uint8_t *buffer, int offset) {
|
|
478
482
|
{
|
479
483
|
uint64_t value = 0;
|
480
484
|
offset = read_raw_varint64(&value, buffer, offset);
|
481
|
-
pb-><%= field.name %> = (int64_t)
|
485
|
+
pb-><%= field.name %> = (int64_t)value;
|
482
486
|
}
|
483
487
|
<% elsif field.type == 'sint32' %>
|
484
488
|
offset = read_raw_varint32(&tag, buffer, offset);
|
@@ -525,7 +529,7 @@ static int read_raw_varint64(uint64_t *tag, const uint8_t *buffer, int offset) {
|
|
525
529
|
for (size_t i = 0; i < (size_t)tag; ++i)
|
526
530
|
offset = read_raw_byte((pb-><%= field.name %>.data + i), buffer, offset);
|
527
531
|
<% end %>
|
528
|
-
|
532
|
+
break;
|
529
533
|
<% end %>
|
530
534
|
}
|
531
535
|
}
|
data/protobuf-generate.gemspec
CHANGED
@@ -2,7 +2,7 @@ $:.unshift(File.join(File.dirname(__FILE__), 'lib'))
|
|
2
2
|
|
3
3
|
spec = Gem::Specification.new do |s|
|
4
4
|
s.name = 'protobuf-generate'
|
5
|
-
s.version = '0.2.
|
5
|
+
s.version = '0.2.3'
|
6
6
|
s.summary = 'A multi-language concrete protobuf code generator.'
|
7
7
|
s.description = 'A simple PEG parser, AST and template based approach to code generation.'
|
8
8
|
s.authors = ['Shane Hanna']
|
data/test/c99/.gitignore
ADDED
@@ -0,0 +1,82 @@
|
|
1
|
+
// Wiretype 0, Varint.
|
2
|
+
|
3
|
+
message ProtoInt32 {
|
4
|
+
required int32 value = 1;
|
5
|
+
}
|
6
|
+
|
7
|
+
message ProtoInt64 {
|
8
|
+
required int64 value = 1;
|
9
|
+
}
|
10
|
+
|
11
|
+
message ProtoUint32 {
|
12
|
+
required uint32 value = 1;
|
13
|
+
}
|
14
|
+
|
15
|
+
message ProtoUint64 {
|
16
|
+
required uint64 value = 1;
|
17
|
+
}
|
18
|
+
|
19
|
+
message ProtoSint32 {
|
20
|
+
required sint32 value = 1;
|
21
|
+
}
|
22
|
+
|
23
|
+
message ProtoSint64 {
|
24
|
+
required sint64 value = 1;
|
25
|
+
}
|
26
|
+
|
27
|
+
message ProtoBool {
|
28
|
+
required bool value = 1;
|
29
|
+
}
|
30
|
+
|
31
|
+
enum ProtoEnumType {
|
32
|
+
One = 1;
|
33
|
+
Two = 2;
|
34
|
+
Three = 3;
|
35
|
+
Four = 4;
|
36
|
+
NinetyNine = 99;
|
37
|
+
}
|
38
|
+
|
39
|
+
message ProtoEnum {
|
40
|
+
required ProtoEnumType value = 1;
|
41
|
+
}
|
42
|
+
|
43
|
+
// Wiretype 1, 64-bit.
|
44
|
+
|
45
|
+
message ProtoFixed64 {
|
46
|
+
required fixed64 value = 1;
|
47
|
+
}
|
48
|
+
|
49
|
+
message ProtoSfixed64 {
|
50
|
+
required sfixed64 value = 1;
|
51
|
+
}
|
52
|
+
|
53
|
+
message ProtoDouble {
|
54
|
+
required double value = 1;
|
55
|
+
}
|
56
|
+
|
57
|
+
|
58
|
+
// Wiretype 2, Length-delimited.
|
59
|
+
|
60
|
+
message ProtoString {
|
61
|
+
required string value = 1; // @size = 32
|
62
|
+
}
|
63
|
+
|
64
|
+
message ProtoBytes {
|
65
|
+
required string value = 1; // @size = 32
|
66
|
+
}
|
67
|
+
|
68
|
+
|
69
|
+
// Wiretype 5, 32-bit.
|
70
|
+
|
71
|
+
message ProtoFixed32 {
|
72
|
+
required fixed32 value = 1;
|
73
|
+
}
|
74
|
+
|
75
|
+
message ProtoSfixed32 {
|
76
|
+
required sfixed32 value = 1;
|
77
|
+
}
|
78
|
+
|
79
|
+
message ProtoFloat {
|
80
|
+
required float value = 1;
|
81
|
+
}
|
82
|
+
|
data/test/c99/makefile
ADDED
@@ -0,0 +1,15 @@
|
|
1
|
+
CFLAGS := -g -Wall -Werror -std=c11
|
2
|
+
|
3
|
+
all: test
|
4
|
+
|
5
|
+
protobufs:
|
6
|
+
bundle exec ../../bin/protobuf-generate c99 alltypes.proto
|
7
|
+
|
8
|
+
test: protobufs test.c alltypes.c
|
9
|
+
$(CC) $(CFLAGS) -o $@ test.c alltypes.c
|
10
|
+
./test
|
11
|
+
|
12
|
+
clean:
|
13
|
+
rm -f test
|
14
|
+
|
15
|
+
real-clean: clean
|
data/test/c99/test.c
ADDED
@@ -0,0 +1,242 @@
|
|
1
|
+
#include "alltypes.h"
|
2
|
+
#include "unit.h"
|
3
|
+
|
4
|
+
#include <float.h>
|
5
|
+
#include <stdbool.h>
|
6
|
+
#include <stddef.h>
|
7
|
+
#include <stdio.h>
|
8
|
+
#include <string.h>
|
9
|
+
|
10
|
+
#define xstr(s) str(s)
|
11
|
+
#define str(s) #s
|
12
|
+
|
13
|
+
#define assert_encode_decode(name, io_value, message) \
|
14
|
+
do { \
|
15
|
+
size_t size; \
|
16
|
+
uint8_t buffer[256]; \
|
17
|
+
name ## _t in = {io_value}; \
|
18
|
+
name ## _t io = {io_value}; \
|
19
|
+
name ## _encode(&io, buffer, sizeof(buffer), &size); \
|
20
|
+
name ## _decode(&io, buffer, size, &size); \
|
21
|
+
unit_assert(memcmp(&io.value, &in.value, sizeof(in.value)) == 0, "encode decode " message); \
|
22
|
+
} while (0)
|
23
|
+
|
24
|
+
static char *test_int32() {
|
25
|
+
assert_encode_decode(proto_int32, 0, "int32 1 byte value 0");
|
26
|
+
assert_encode_decode(proto_int32, 1, "int32 1 byte value 1");
|
27
|
+
assert_encode_decode(proto_int32, 1234, "int32 2 byte value 1234");
|
28
|
+
assert_encode_decode(proto_int32, 123456, "int32 3 byte value 123456");
|
29
|
+
assert_encode_decode(proto_int32, 12345678, "int32 4 byte value 12345678");
|
30
|
+
assert_encode_decode(proto_int32, INT32_MAX, "int32 5 byte value " xstr(INT32_MAX));
|
31
|
+
|
32
|
+
assert_encode_decode(proto_int32, -1, "int32 10 byte value -1");
|
33
|
+
assert_encode_decode(proto_int32, -1234, "int32 10 byte value -1234");
|
34
|
+
assert_encode_decode(proto_int32, -123456, "int32 10 byte value -123456");
|
35
|
+
assert_encode_decode(proto_int32, -12345678, "int32 10 byte value -12345678");
|
36
|
+
assert_encode_decode(proto_int32, INT32_MIN, "int32 10 byte value " xstr(INT32_MIN));
|
37
|
+
return 0;
|
38
|
+
}
|
39
|
+
|
40
|
+
static char *test_int64() {
|
41
|
+
assert_encode_decode(proto_int64, 0, "int64 1 byte value 0");
|
42
|
+
assert_encode_decode(proto_int64, 1, "int64 1 byte value 1");
|
43
|
+
assert_encode_decode(proto_int64, 1234, "int64 2 byte value 1234");
|
44
|
+
assert_encode_decode(proto_int64, 123456, "int64 3 byte value 123456");
|
45
|
+
assert_encode_decode(proto_int64, 12345678, "int64 4 byte value 12345678");
|
46
|
+
assert_encode_decode(proto_int64, INT64_MAX, "int64 10 byte value " xstr(INT64_MAX));
|
47
|
+
|
48
|
+
assert_encode_decode(proto_int64, -1, "int64 10 byte value -1");
|
49
|
+
assert_encode_decode(proto_int64, -1234, "int64 10 byte value -1234");
|
50
|
+
assert_encode_decode(proto_int64, -123456, "int64 10 byte value -123456");
|
51
|
+
assert_encode_decode(proto_int64, -12345678, "int64 10 byte value -12345678");
|
52
|
+
assert_encode_decode(proto_int64, INT64_MIN, "int64 10 byte value " xstr(INT64_MIN));
|
53
|
+
return 0;
|
54
|
+
}
|
55
|
+
|
56
|
+
static char *test_uint32() {
|
57
|
+
assert_encode_decode(proto_uint32, 0, "uint32 1 byte value 0");
|
58
|
+
assert_encode_decode(proto_uint32, 1, "uint32 1 byte value 1");
|
59
|
+
assert_encode_decode(proto_uint32, 1, "uint32 1 byte value 1");
|
60
|
+
assert_encode_decode(proto_uint32, UINT32_MAX, "uint32 5 byte value " xstr(UINT32_MAX));
|
61
|
+
return 0;
|
62
|
+
}
|
63
|
+
|
64
|
+
static char *test_uint64() {
|
65
|
+
assert_encode_decode(proto_uint64, 0, "uint64 1 byte value 0");
|
66
|
+
assert_encode_decode(proto_uint64, 1, "uint64 1 byte value 1");
|
67
|
+
assert_encode_decode(proto_uint64, 1, "uint64 1 byte value 1");
|
68
|
+
assert_encode_decode(proto_uint64, UINT64_MAX, "uint64 10 byte value " xstr(UINT64_MAX));
|
69
|
+
return 0;
|
70
|
+
}
|
71
|
+
|
72
|
+
static char *test_sint32() {
|
73
|
+
assert_encode_decode(proto_sint32, 0, "sint32 1 byte value 0");
|
74
|
+
assert_encode_decode(proto_sint32, 1, "sint32 1 byte value 1");
|
75
|
+
assert_encode_decode(proto_sint32, 1234, "sint32 2 byte value 1234");
|
76
|
+
assert_encode_decode(proto_sint32, 123456, "sint32 3 byte value 123456");
|
77
|
+
assert_encode_decode(proto_sint32, 12345678, "sint32 4 byte value 12345678");
|
78
|
+
assert_encode_decode(proto_sint32, INT32_MAX, "sint32 5 byte value " xstr(INT32_MAX));
|
79
|
+
|
80
|
+
assert_encode_decode(proto_sint32, -1, "sint32 10 byte value -1");
|
81
|
+
assert_encode_decode(proto_sint32, -1234, "sint32 10 byte value -1234");
|
82
|
+
assert_encode_decode(proto_sint32, -123456, "sint32 10 byte value -123456");
|
83
|
+
assert_encode_decode(proto_sint32, -12345678, "sint32 10 byte value -12345678");
|
84
|
+
assert_encode_decode(proto_sint32, INT32_MIN, "sint32 10 byte value " xstr(INT32_MIN));
|
85
|
+
return 0;
|
86
|
+
}
|
87
|
+
|
88
|
+
static char *test_sint64() {
|
89
|
+
assert_encode_decode(proto_sint64, 0, "sint64 value 0");
|
90
|
+
assert_encode_decode(proto_sint64, 1, "sint64 value 1");
|
91
|
+
assert_encode_decode(proto_sint64, 1234, "sint64 value 1234");
|
92
|
+
assert_encode_decode(proto_sint64, 123456, "sint64 value 123456");
|
93
|
+
assert_encode_decode(proto_sint64, 12345678, "sint64 value 12345678");
|
94
|
+
assert_encode_decode(proto_sint64, INT64_MAX, "sint32 value " xstr(INT64_MAX));
|
95
|
+
|
96
|
+
assert_encode_decode(proto_sint64, -1, "sint64 value -1");
|
97
|
+
assert_encode_decode(proto_sint64, -1234, "sint64 value -1234");
|
98
|
+
assert_encode_decode(proto_sint64, -123456, "sint64 value -123456");
|
99
|
+
assert_encode_decode(proto_sint64, -12345678, "sint64 value -12345678");
|
100
|
+
assert_encode_decode(proto_sint64, INT64_MIN, "sint64 value " xstr(INT64_MIN));
|
101
|
+
return 0;
|
102
|
+
}
|
103
|
+
|
104
|
+
static char *test_bool() {
|
105
|
+
assert_encode_decode(proto_bool, true, "bool value true");
|
106
|
+
assert_encode_decode(proto_bool, false, "bool value false");
|
107
|
+
assert_encode_decode(proto_bool, 1, "bool value 1");
|
108
|
+
assert_encode_decode(proto_bool, 0, "bool value 0");
|
109
|
+
return 0;
|
110
|
+
}
|
111
|
+
|
112
|
+
static char *test_enum() {
|
113
|
+
assert_encode_decode(proto_enum, PROTO_ENUM_TYPE_ONE, "enum value " str(PROTO_ENUM_TYPE_ONE));
|
114
|
+
assert_encode_decode(proto_enum, PROTO_ENUM_TYPE_TWO, "enum value " str(PROTO_ENUM_TYPE_TWO));
|
115
|
+
assert_encode_decode(proto_enum, PROTO_ENUM_TYPE_NINETY_NINE, "enum value " str(PROTO_ENUM_TYPE_NINETY_NINE));
|
116
|
+
return 0;
|
117
|
+
}
|
118
|
+
|
119
|
+
static char *test_fixed64() {
|
120
|
+
assert_encode_decode(proto_fixed64, 0, "fixed64 1 byte value 0");
|
121
|
+
assert_encode_decode(proto_fixed64, 1, "fixed64 1 byte value 1");
|
122
|
+
assert_encode_decode(proto_fixed64, 1, "fixed64 1 byte value 1");
|
123
|
+
assert_encode_decode(proto_fixed64, UINT64_MAX, "fixed64 10 byte value " xstr(UINT64_MAX));
|
124
|
+
return 0;
|
125
|
+
}
|
126
|
+
|
127
|
+
static char *test_sfixed64() {
|
128
|
+
assert_encode_decode(proto_sfixed64, 0, "sfixed64 value 0");
|
129
|
+
assert_encode_decode(proto_sfixed64, 1, "sfixed64 value 1");
|
130
|
+
assert_encode_decode(proto_sfixed64, 1234, "sfixed64 value 1234");
|
131
|
+
assert_encode_decode(proto_sfixed64, 123456, "sfixed64 value 123456");
|
132
|
+
assert_encode_decode(proto_sfixed64, 12345678, "sfixed64 value 12345678");
|
133
|
+
assert_encode_decode(proto_sfixed64, INT64_MAX, "sfixed32 value " xstr(INT64_MAX));
|
134
|
+
|
135
|
+
assert_encode_decode(proto_sfixed64, -1, "sfixed64 value -1");
|
136
|
+
assert_encode_decode(proto_sfixed64, -1234, "sfixed64 value -1234");
|
137
|
+
assert_encode_decode(proto_sfixed64, -123456, "sfixed64 value -123456");
|
138
|
+
assert_encode_decode(proto_sfixed64, -12345678, "sfixed64 value -12345678");
|
139
|
+
assert_encode_decode(proto_sfixed64, INT64_MIN, "sfixed64 value " xstr(INT64_MIN));
|
140
|
+
return 0;
|
141
|
+
}
|
142
|
+
|
143
|
+
static char *test_double() {
|
144
|
+
assert_encode_decode(proto_double, DBL_MAX, "double value " xstr(DBL_MAX));
|
145
|
+
assert_encode_decode(proto_double, DBL_MIN, "double value " xstr(DBL_MIN));
|
146
|
+
return 0;
|
147
|
+
}
|
148
|
+
|
149
|
+
static char *test_string() {
|
150
|
+
size_t size;
|
151
|
+
uint8_t buffer[256];
|
152
|
+
|
153
|
+
proto_string_t io;
|
154
|
+
proto_string_t in;
|
155
|
+
strcpy((char *)in.value.data, "test");
|
156
|
+
in.value.size = 5;
|
157
|
+
|
158
|
+
proto_string_encode(&in, buffer, sizeof(buffer), &size);
|
159
|
+
proto_string_decode(&io, buffer, size, &size);
|
160
|
+
|
161
|
+
unit_assert((io.value.size == in.value.size), "encode decode string size 5");
|
162
|
+
unit_assert(memcmp(&io.value.data, &in.value.data, in.value.size) == 0, "encode decode string \"test\"");
|
163
|
+
return 0;
|
164
|
+
}
|
165
|
+
|
166
|
+
static char *test_bytes() {
|
167
|
+
size_t size;
|
168
|
+
uint8_t buffer[256];
|
169
|
+
|
170
|
+
proto_bytes_t io;
|
171
|
+
proto_bytes_t in;
|
172
|
+
memcpy(in.value.data, "test", 4);
|
173
|
+
in.value.size = 4;
|
174
|
+
|
175
|
+
proto_bytes_encode(&in, buffer, sizeof(buffer), &size);
|
176
|
+
proto_bytes_decode(&io, buffer, size, &size);
|
177
|
+
|
178
|
+
unit_assert((io.value.size == in.value.size), "encode decode bytes size 4");
|
179
|
+
unit_assert(memcmp(&io.value.data, &in.value.data, in.value.size) == 0, "encode decode bytes \"test\"");
|
180
|
+
return 0;
|
181
|
+
}
|
182
|
+
|
183
|
+
static char *test_fixed32() {
|
184
|
+
assert_encode_decode(proto_fixed32, 0, "fixed32 1 byte value 0");
|
185
|
+
assert_encode_decode(proto_fixed32, 1, "fixed32 1 byte value 1");
|
186
|
+
assert_encode_decode(proto_fixed32, 1, "fixed32 1 byte value 1");
|
187
|
+
assert_encode_decode(proto_fixed32, UINT32_MAX, "fixed32 10 byte value " xstr(UINT32_MAX));
|
188
|
+
return 0;
|
189
|
+
}
|
190
|
+
|
191
|
+
static char *test_sfixed32() {
|
192
|
+
assert_encode_decode(proto_sfixed32, 0, "sfixed32 value 0");
|
193
|
+
assert_encode_decode(proto_sfixed32, 1, "sfixed32 value 1");
|
194
|
+
assert_encode_decode(proto_sfixed32, 1234, "sfixed32 value 1234");
|
195
|
+
assert_encode_decode(proto_sfixed32, 123456, "sfixed32 value 123456");
|
196
|
+
assert_encode_decode(proto_sfixed32, 12345678, "sfixed32 value 12345678");
|
197
|
+
assert_encode_decode(proto_sfixed32, INT32_MAX, "sfixed32 value " xstr(INT32_MAX));
|
198
|
+
|
199
|
+
assert_encode_decode(proto_sfixed32, -1, "sfixed32 value -1");
|
200
|
+
assert_encode_decode(proto_sfixed32, -1234, "sfixed32 value -1234");
|
201
|
+
assert_encode_decode(proto_sfixed32, -123456, "sfixed32 value -123456");
|
202
|
+
assert_encode_decode(proto_sfixed32, -12345678, "sfixed32 value -12345678");
|
203
|
+
assert_encode_decode(proto_sfixed32, INT32_MIN, "sfixed32 value " xstr(INT32_MIN));
|
204
|
+
return 0;
|
205
|
+
}
|
206
|
+
|
207
|
+
static char *test_float() {
|
208
|
+
assert_encode_decode(proto_float, FLT_MAX, "float value " xstr(FLT_MAX));
|
209
|
+
assert_encode_decode(proto_float, FLT_MIN, "float value " xstr(FLT_MIN));
|
210
|
+
return 0;
|
211
|
+
}
|
212
|
+
|
213
|
+
static char *test_all() {
|
214
|
+
unit_run(test_int32);
|
215
|
+
unit_run(test_int64);
|
216
|
+
unit_run(test_uint32);
|
217
|
+
unit_run(test_uint64);
|
218
|
+
unit_run(test_sint32);
|
219
|
+
unit_run(test_sint64);
|
220
|
+
unit_run(test_bool);
|
221
|
+
unit_run(test_enum);
|
222
|
+
unit_run(test_fixed64);
|
223
|
+
unit_run(test_sfixed64);
|
224
|
+
unit_run(test_double);
|
225
|
+
unit_run(test_string);
|
226
|
+
unit_run(test_bytes);
|
227
|
+
unit_run(test_fixed32);
|
228
|
+
unit_run(test_sfixed32);
|
229
|
+
unit_run(test_float);
|
230
|
+
return 0;
|
231
|
+
}
|
232
|
+
|
233
|
+
int main(int argc, char **argv) {
|
234
|
+
char *result = test_all();
|
235
|
+
printf("tests: %u\n", unit_tests);
|
236
|
+
printf("assertions: %u\n", unit_assertions);
|
237
|
+
|
238
|
+
if (result != 0) printf("failed: %s\n", result);
|
239
|
+
else printf("passed: all\n");
|
240
|
+
|
241
|
+
return result != 0;
|
242
|
+
}
|
data/test/c99/unit.h
ADDED
@@ -0,0 +1,25 @@
|
|
1
|
+
/*
|
2
|
+
Mini Unit
|
3
|
+
|
4
|
+
Shamelessly taken and tweaked to taste from
|
5
|
+
http://www.jera.com/techinfo/jtns/jtn002.html
|
6
|
+
*/
|
7
|
+
|
8
|
+
#pragma once
|
9
|
+
|
10
|
+
static unsigned int unit_tests = 0;
|
11
|
+
static unsigned int unit_assertions = 0;
|
12
|
+
|
13
|
+
#define unit_assert(test, message) \
|
14
|
+
do { \
|
15
|
+
unit_assertions++; \
|
16
|
+
if (!(test)) return message; \
|
17
|
+
} while (0)
|
18
|
+
|
19
|
+
#define unit_run(test) \
|
20
|
+
do { \
|
21
|
+
unit_tests++; \
|
22
|
+
char *message = test(); \
|
23
|
+
if (message) return message; \
|
24
|
+
} while (0)
|
25
|
+
|
metadata
CHANGED
@@ -1,14 +1,14 @@
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
2
2
|
name: protobuf-generate
|
3
3
|
version: !ruby/object:Gem::Version
|
4
|
-
version: 0.2.
|
4
|
+
version: 0.2.3
|
5
5
|
platform: ruby
|
6
6
|
authors:
|
7
7
|
- Shane Hanna
|
8
8
|
autorequire:
|
9
9
|
bindir: bin
|
10
10
|
cert_chain: []
|
11
|
-
date: 2013-08-
|
11
|
+
date: 2013-08-31 00:00:00.000000000 Z
|
12
12
|
dependencies:
|
13
13
|
- !ruby/object:Gem::Dependency
|
14
14
|
name: parslet
|
@@ -58,6 +58,11 @@ files:
|
|
58
58
|
- lib/protobuf/generate/language/c/h.erb
|
59
59
|
- lib/protobuf/generate/parser.rb
|
60
60
|
- protobuf-generate.gemspec
|
61
|
+
- test/c99/.gitignore
|
62
|
+
- test/c99/alltypes.proto
|
63
|
+
- test/c99/makefile
|
64
|
+
- test/c99/test.c
|
65
|
+
- test/c99/unit.h
|
61
66
|
homepage: https://bitbucket.org/shanehanna/protobuf-generate
|
62
67
|
licenses:
|
63
68
|
- MIT
|
@@ -82,4 +87,9 @@ rubygems_version: 2.0.3
|
|
82
87
|
signing_key:
|
83
88
|
specification_version: 4
|
84
89
|
summary: A multi-language concrete protobuf code generator.
|
85
|
-
test_files:
|
90
|
+
test_files:
|
91
|
+
- test/c99/.gitignore
|
92
|
+
- test/c99/alltypes.proto
|
93
|
+
- test/c99/makefile
|
94
|
+
- test/c99/test.c
|
95
|
+
- test/c99/unit.h
|