libbin 1.0.7 → 1.0.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,65 +1,1474 @@
1
1
  #include "ruby.h"
2
- #include "./half.h"
3
- #include "./pghalf.h"
2
+ #include "./libbin_c.h"
4
3
 
5
- union float_u {
6
- float f;
7
- uint32_t i;
4
+ VALUE cField;
5
+ VALUE mLibBin;
6
+ VALUE cDataConverter;
7
+
8
+ static VALUE rb_str_dot_dot;
9
+ static VALUE rb_str___parent;
10
+ static VALUE rb_str_backslash;
11
+ static VALUE rb_str_dot;
12
+
13
+ struct cField_data {
14
+ VALUE name;
15
+ VALUE type;
16
+ VALUE length;
17
+ VALUE count;
18
+ VALUE offset;
19
+ VALUE sequence;
20
+ VALUE condition;
21
+ VALUE relative_offset;
22
+ ID getter;
23
+ ID setter;
24
+ };
25
+
26
+ static void cField_mark(void* data) {
27
+ void *start = data;
28
+ void *end = &((struct cField_data*)data)->getter;
29
+ rb_gc_mark_locations((VALUE *)start, (VALUE *)end);
30
+ }
31
+
32
+ static size_t cField_size(const void* data) {
33
+ (void)data;
34
+ return sizeof(struct cField_data);
35
+ }
36
+
37
+ static const rb_data_type_t cField_type = {
38
+ .wrap_struct_name = "cField_data",
39
+ .function = {
40
+ .dmark = cField_mark,
41
+ .dfree = RUBY_DEFAULT_FREE,
42
+ .dsize = cField_size,
43
+ },
44
+ .data = NULL,
45
+ .flags = RUBY_TYPED_FREE_IMMEDIATELY
8
46
  };
9
47
 
48
+ static VALUE cField_alloc(VALUE self) {
49
+ struct cField_data *data;
50
+ VALUE res = TypedData_Make_Struct(self, struct cField_data, &cField_type, data);
51
+ return res;
52
+ }
53
+
54
+ static ID id_gsub;
55
+
56
+ static inline VALUE cField_preprocess_expression(VALUE self, VALUE expression) {
57
+ if (T_STRING == TYPE(expression)) {
58
+ VALUE proc = rb_str_new_cstr("proc {");
59
+ rb_str_buf_append(proc, rb_funcall(rb_funcall(expression, id_gsub, 2, rb_str_dot_dot, rb_str___parent), id_gsub, 2, rb_str_backslash, rb_str_dot));
60
+ rb_str_cat_cstr(proc, "}");
61
+ return rb_obj_instance_eval(1, &proc, self);
62
+ } else
63
+ return expression;
64
+ }
65
+
66
+ static VALUE cField_initialize(
67
+ VALUE self,
68
+ VALUE name,
69
+ VALUE type,
70
+ VALUE length,
71
+ VALUE count,
72
+ VALUE offset,
73
+ VALUE sequence,
74
+ VALUE condition,
75
+ VALUE relative_offset) {
76
+ VALUE tmp;
77
+ struct cField_data *data;
78
+ TypedData_Get_Struct(self, struct cField_data, &cField_type, data);
79
+ data->name = name;
80
+ tmp = rb_str_dup(rb_obj_as_string(name));
81
+ data->getter = rb_intern_str(tmp);
82
+ data->setter = rb_intern_str(rb_str_cat(tmp, "=", 1));
83
+ data->type = cField_preprocess_expression(self, type);
84
+ data->length = cField_preprocess_expression(self, length);
85
+ data->count = cField_preprocess_expression(self, count);
86
+ data->offset = cField_preprocess_expression(self, offset);
87
+ data->sequence = sequence;
88
+ data->condition = cField_preprocess_expression(self, condition);
89
+ data->relative_offset = relative_offset;
90
+ return self;
91
+ }
92
+
93
+ static VALUE cField_name(VALUE self) {
94
+ struct cField_data *data;
95
+ TypedData_Get_Struct(self, struct cField_data, &cField_type, data);
96
+ return data->name;
97
+ }
98
+
99
+ static VALUE cField_get_type(VALUE self) {
100
+ struct cField_data *data;
101
+ TypedData_Get_Struct(self, struct cField_data, &cField_type, data);
102
+ return data->type;
103
+ }
104
+
105
+ static VALUE cField_length(VALUE self) {
106
+ struct cField_data *data;
107
+ TypedData_Get_Struct(self, struct cField_data, &cField_type, data);
108
+ return data->length;
109
+ }
110
+
111
+ static VALUE cField_count(VALUE self) {
112
+ struct cField_data *data;
113
+ TypedData_Get_Struct(self, struct cField_data, &cField_type, data);
114
+ return data->count;
115
+ }
116
+
117
+ static VALUE cField_offset(VALUE self) {
118
+ struct cField_data *data;
119
+ TypedData_Get_Struct(self, struct cField_data, &cField_type, data);
120
+ return data->offset;
121
+ }
122
+
123
+ static VALUE cField_sequence(VALUE self) {
124
+ struct cField_data *data;
125
+ TypedData_Get_Struct(self, struct cField_data, &cField_type, data);
126
+ return data->sequence;
127
+ }
128
+
129
+ static VALUE cField_condition(VALUE self) {
130
+ struct cField_data *data;
131
+ TypedData_Get_Struct(self, struct cField_data, &cField_type, data);
132
+ return data->condition;
133
+ }
134
+
135
+ static VALUE cField_relative_offset(VALUE self) {
136
+ struct cField_data *data;
137
+ TypedData_Get_Struct(self, struct cField_data, &cField_type, data);
138
+ return data->relative_offset;
139
+ }
140
+
141
+ static void define_cField() {
142
+ VALUE ary = rb_ary_new_capa(4);
143
+ id_gsub = rb_intern("gsub");
144
+
145
+ rb_str_dot_dot = rb_str_new_cstr("..");
146
+ rb_ary_store(ary, 0, rb_str_dot_dot);
147
+ rb_str___parent = rb_str_new_cstr("__parent");
148
+ rb_ary_store(ary, 1, rb_str___parent);
149
+ rb_str_backslash = rb_str_new_cstr("\\");
150
+ rb_ary_store(ary, 2, rb_str_backslash);
151
+ rb_str_dot = rb_str_new_cstr(".");
152
+ rb_ary_store(ary, 3, rb_str_dot);
153
+
154
+ cField = rb_define_class_under(mLibBin, "Field", rb_cObject);
155
+ rb_define_alloc_func(cField, cField_alloc);
156
+ rb_const_set(cField, rb_intern("STRINGS"), ary);
157
+ rb_define_method(cField, "initialize", cField_initialize, 8);
158
+ rb_define_method(cField, "name", cField_name, 0);
159
+ rb_define_method(cField, "type", cField_get_type, 0);
160
+ rb_define_method(cField, "length", cField_length, 0);
161
+ rb_define_method(cField, "count", cField_count, 0);
162
+ rb_define_method(cField, "offset", cField_offset, 0);
163
+ rb_define_method(cField, "sequence", cField_sequence, 0);
164
+ rb_define_method(cField, "sequence?", cField_sequence, 0);
165
+ rb_define_method(cField, "condition", cField_condition, 0);
166
+ rb_define_method(cField, "relative_offset?", cField_relative_offset, 0);
167
+ }
168
+
169
+ struct cDataConverter_data {
170
+ VALUE __input;
171
+ VALUE __output;
172
+ VALUE __input_big;
173
+ VALUE __output_big;
174
+ VALUE __parent;
175
+ VALUE __index;
176
+ VALUE __position;
177
+ VALUE __cur_position;
178
+ // field specific data
179
+ VALUE __offset;
180
+ VALUE __condition;
181
+ VALUE __type;
182
+ VALUE __length;
183
+ VALUE __count;
184
+ VALUE __iterator;
185
+ };
186
+
187
+ static void cDataConverter_mark(void* data) {
188
+ void *start = data;
189
+ void *end = (char *)data + sizeof(struct cDataConverter_data);
190
+ rb_gc_mark_locations((VALUE *)start, (VALUE *)end);
191
+ }
192
+
193
+ static size_t cDataConverter_size(const void* data) {
194
+ (void)data;
195
+ return sizeof(struct cDataConverter_data);
196
+ }
197
+
198
+ static const rb_data_type_t cDataConverter_type = {
199
+ .wrap_struct_name = "cDataConverter_data",
200
+ .function = {
201
+ .dmark = cDataConverter_mark,
202
+ .dfree = RUBY_DEFAULT_FREE,
203
+ .dsize = cDataConverter_size,
204
+ },
205
+ .data = NULL,
206
+ .flags = RUBY_TYPED_FREE_IMMEDIATELY
207
+ };
208
+
209
+ static VALUE cDataConverter_alloc(VALUE self) {
210
+ struct cDataConverter_data *data;
211
+ VALUE res = TypedData_Make_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
212
+ return res;
213
+ }
214
+
215
+ static VALUE cDataConverter_initialize(VALUE self) {
216
+ struct cDataConverter_data *data;
217
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
218
+ data->__input = Qnil;
219
+ data->__output = Qnil;
220
+ data->__input_big = Qnil;
221
+ data->__output_big = Qnil;
222
+ data->__parent = Qnil;
223
+ data->__index = Qnil;
224
+ data->__position = Qnil;
225
+ data->__cur_position = Qnil;
226
+ data->__offset = Qnil;
227
+ data->__condition = Qnil;
228
+ data->__type = Qnil;
229
+ data->__length = Qnil;
230
+ data->__count = Qnil;
231
+ data->__iterator = Qnil;
232
+ return self;
233
+ }
234
+
235
+ /* attr_reader :__parent
236
+ attr_reader :__index
237
+ attr_reader :__iterator
238
+ attr_reader :__position */
239
+
240
+ static VALUE cDataConverter_parent(VALUE self) {
241
+ struct cDataConverter_data *data;
242
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
243
+ return data->__parent;
244
+ }
245
+
246
+ static VALUE cDataConverter_index(VALUE self) {
247
+ struct cDataConverter_data *data;
248
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
249
+ return data->__index;
250
+ }
251
+
252
+ static VALUE cDataConverter_iterator(VALUE self) {
253
+ struct cDataConverter_data *data;
254
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
255
+ return data->__iterator;
256
+ }
257
+
258
+ static VALUE cDataConverter_position(VALUE self) {
259
+ struct cDataConverter_data *data;
260
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
261
+ return data->__position;
262
+ }
263
+
264
+ /* attr_reader :__input
265
+ attr_reader :__output
266
+ attr_reader :__input_big
267
+ attr_reader :__output_big */
268
+
269
+ static VALUE cDataConverter_input(VALUE self) {
270
+ struct cDataConverter_data *data;
271
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
272
+ return data->__input;
273
+ }
274
+
275
+ static VALUE cDataConverter_output(VALUE self) {
276
+ struct cDataConverter_data *data;
277
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
278
+ return data->__output;
279
+ }
280
+
281
+ static VALUE cDataConverter_input_big(VALUE self) {
282
+ struct cDataConverter_data *data;
283
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
284
+ return data->__input_big;
285
+ }
286
+
287
+ static VALUE cDataConverter_output_big(VALUE self) {
288
+ struct cDataConverter_data *data;
289
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
290
+ return data->__output_big;
291
+ }
292
+
293
+ ID id_tell;
294
+
295
+ /* def __set_convert_type(input, output, input_big, output_big, parent, index)
296
+ @__input_big = input_big
297
+ @__output_big = output_big
298
+ @__input = input
299
+ @__output = output
300
+ @__parent = parent
301
+ @__index = index
302
+ @__position = input.tell
303
+ @__cur_position = @__position
304
+ end */
305
+
306
+ static inline VALUE cDataConverter_set_convert_type(
307
+ VALUE self,
308
+ VALUE input,
309
+ VALUE output,
310
+ VALUE input_big,
311
+ VALUE output_big,
312
+ VALUE parent,
313
+ VALUE index)
314
+ {
315
+ struct cDataConverter_data *data;
316
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
317
+ data->__input = input;
318
+ data->__output = output;
319
+ data->__input_big = input_big;
320
+ data->__output_big = output_big;
321
+ data->__parent = parent;
322
+ data->__index = index;
323
+ data->__position = rb_funcall(input, id_tell, 0);
324
+ data->__cur_position = data->__position;
325
+ return Qnil;
326
+ }
327
+
328
+ /* def __unset_convert_type
329
+ @__input_big = nil
330
+ @__output_big = nil
331
+ @__input = nil
332
+ @__output = nil
333
+ @__parent = nil
334
+ @__index = nil
335
+ @__position = nil
336
+ @__cur_position = nil
337
+ end */
338
+
339
+ static inline VALUE cDataConverter_unset_convert_type(VALUE self) {
340
+ struct cDataConverter_data *data;
341
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
342
+ data->__input = Qnil;
343
+ data->__output = Qnil;
344
+ data->__input_big = Qnil;
345
+ data->__output_big = Qnil;
346
+ data->__parent = Qnil;
347
+ data->__index = Qnil;
348
+ data->__position = Qnil;
349
+ data->__cur_position = Qnil;
350
+ return Qnil;
351
+ }
352
+
353
+ /* def __set_size_type(position, parent, index)
354
+ @__parent = parent
355
+ @__index = index
356
+ @__position = position
357
+ @__cur_position = @__position
358
+ end */
359
+
360
+ static inline VALUE cDataConverter_set_size_type(
361
+ VALUE self,
362
+ VALUE position,
363
+ VALUE parent,
364
+ VALUE index)
365
+ {
366
+ struct cDataConverter_data *data;
367
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
368
+ data->__parent = parent;
369
+ data->__index = index;
370
+ data->__position = position;
371
+ data->__cur_position = data->__position;
372
+ return Qnil;
373
+ }
374
+
375
+ /* def __unset_size_type
376
+ @__parent = nil
377
+ @__index = nil
378
+ @__position = nil
379
+ @__cur_position = nil
380
+ end */
381
+
382
+ static inline VALUE cDataConverter_unset_size_type(VALUE self) {
383
+ struct cDataConverter_data *data;
384
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
385
+ data->__parent = Qnil;
386
+ data->__index = Qnil;
387
+ data->__position = Qnil;
388
+ data->__cur_position = Qnil;
389
+ return Qnil;
390
+ }
391
+
392
+ /* def __set_load_type(input, input_big, parent, index)
393
+ @__input_big = input_big
394
+ @__input = input
395
+ @__parent = parent
396
+ @__index = index
397
+ @__position = input.tell
398
+ @__cur_position = @__position
399
+ end */
400
+
401
+ static inline VALUE cDataConverter_set_load_type(
402
+ VALUE self,
403
+ VALUE input,
404
+ VALUE input_big,
405
+ VALUE parent,
406
+ VALUE index)
407
+ {
408
+ struct cDataConverter_data *data;
409
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
410
+ data->__input = input;
411
+ data->__input_big = input_big;
412
+ data->__parent = parent;
413
+ data->__index = index;
414
+ data->__position = rb_funcall(input, id_tell, 0);
415
+ data->__cur_position = data->__position;
416
+ return Qnil;
417
+ }
418
+
419
+ /* def __unset_load_type
420
+ @__input_big = nil
421
+ @__input = nil
422
+ @__parent = nil
423
+ @__index = nil
424
+ @__position = nil
425
+ @__cur_position = nil
426
+ end */
427
+
428
+ static inline VALUE cDataConverter_unset_load_type(VALUE self) {
429
+ struct cDataConverter_data *data;
430
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
431
+ data->__input = Qnil;
432
+ data->__input_big = Qnil;
433
+ data->__parent = Qnil;
434
+ data->__index = Qnil;
435
+ data->__position = Qnil;
436
+ data->__cur_position = Qnil;
437
+ return Qnil;
438
+ }
439
+
440
+ /* def __set_dump_type(output, output_big, parent, index)
441
+ @__output_big = output_big
442
+ @__output = output
443
+ @__parent = parent
444
+ @__index = index
445
+ @__position = output.tell
446
+ @__cur_position = @__position
447
+ end */
448
+
449
+ static inline VALUE cDataConverter_set_dump_type(
450
+ VALUE self,
451
+ VALUE output,
452
+ VALUE output_big,
453
+ VALUE parent,
454
+ VALUE index)
455
+ {
456
+ struct cDataConverter_data *data;
457
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
458
+ data->__output = output;
459
+ data->__output_big = output_big;
460
+ data->__parent = parent;
461
+ data->__index = index;
462
+ data->__position = rb_funcall(output, id_tell, 0);
463
+ data->__cur_position = data->__position;
464
+ return Qnil;
465
+ }
466
+
467
+ /* def __unset_dump_type
468
+ @__output_big = nil
469
+ @__output = nil
470
+ @__parent = nil
471
+ @__index = nil
472
+ @__position = nil
473
+ @__cur_position = nil
474
+ end */
475
+
476
+ static inline VALUE cDataConverter_unset_dump_type(VALUE self) {
477
+ struct cDataConverter_data *data;
478
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
479
+ data->__output = Qnil;
480
+ data->__output_big = Qnil;
481
+ data->__parent = Qnil;
482
+ data->__index = Qnil;
483
+ data->__position = Qnil;
484
+ data->__cur_position = Qnil;
485
+ return Qnil;
486
+ }
487
+
488
+ /* def __decode_expression(sym)
489
+ case sym
490
+ when Proc
491
+ return sym.call
492
+ else
493
+ return sym
494
+ end
495
+ end */
496
+
497
+ static ID id_instance_exec;
498
+
499
+ static inline VALUE cDataConverter_decode_expression(VALUE self, VALUE expression) {
500
+ if (rb_obj_is_proc(expression))
501
+ return rb_funcall_with_block(self, id_instance_exec, 0, NULL, expression);
502
+ else
503
+ return expression;
504
+ }
505
+
506
+ /* def __decode_seek_offset(offset, relative_offset)
507
+ return nil unless offset
508
+ offset = __decode_expression(offset)
509
+ return false if offset == 0x0
510
+ offset += @__position if relative_offset
511
+ @__cur_position = offset
512
+ @__input.seek(offset) if @__input
513
+ @__output.seek(offset) if @__output
514
+ offset
515
+ end */
516
+
517
+ ID id_seek;
518
+
519
+ static inline VALUE cDataConverter_decode_seek_offset(VALUE self, VALUE offset, VALUE relative_offset) {
520
+ struct cDataConverter_data *data;
521
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
522
+ if (!RTEST(offset))
523
+ return Qnil;
524
+ ptrdiff_t off = NUM2LL(cDataConverter_decode_expression(self, offset));
525
+ if (off == 0)
526
+ return Qfalse;
527
+ if (RTEST(relative_offset))
528
+ off += NUM2LL(data->__position);
529
+ data->__cur_position = LL2NUM(off);
530
+ if (RTEST(data->__input))
531
+ rb_funcall(data->__input, id_seek, 1, data->__cur_position);
532
+ if (RTEST(data->__output))
533
+ rb_funcall(data->__output, id_seek, 1, data->__cur_position);
534
+ return data->__cur_position;
535
+ }
536
+
537
+ /* def __decode_condition(condition)
538
+ return true unless condition
539
+ __decode_expression(condition)
540
+ end */
541
+
542
+ static inline VALUE cDataConverter_decode_condition(VALUE self, VALUE condition) {
543
+ if (!RTEST(condition))
544
+ return Qtrue;
545
+ return cDataConverter_decode_expression(self, condition);
546
+ }
547
+
548
+ /* def __decode_count(count)
549
+ return 1 unless count
550
+ __decode_expression(count)
551
+ end */
552
+
553
+ static inline VALUE cDataConverter_decode_count(VALUE self, VALUE count) {
554
+ if (!RTEST(count))
555
+ return INT2FIX(1);
556
+ return cDataConverter_decode_expression(self, count);
557
+ }
558
+
559
+ /* def __decode_type(type)
560
+ __decode_expression(type)
561
+ end */
562
+
563
+ static inline VALUE cDataConverter_decode_type(VALUE self, VALUE type) {
564
+ return cDataConverter_decode_expression(self, type);
565
+ }
566
+
567
+ /* def __decode_length(length)
568
+ __decode_expression(length)
569
+ end */
570
+
571
+ static inline VALUE cDataConverter_decode_length(VALUE self, VALUE length) {
572
+ if (NIL_P(length))
573
+ return Qnil;
574
+ return cDataConverter_decode_expression(self, length);
575
+ }
576
+
577
+ /* def __decode_static_conditions(field)
578
+ @__offset = nil
579
+ @__condition = nil
580
+ @__type = nil
581
+ @__length = nil
582
+ @__count = nil
583
+ unless field.sequence?
584
+ @__offset = __decode_seek_offset(field.offset, field.relative_offset?)
585
+ throw :ignored, nil if @__offset == false
586
+ @__condition = __decode_condition(field.condition)
587
+ throw :ignored, nil unless @__condition
588
+ @__type = __decode_type(field.type)
589
+ @__length = __decode_length(field.length)
590
+ end
591
+ @__count = __decode_count(field.count)
592
+ end */
593
+
594
+ static inline VALUE cDataConverter_decode_static_conditions(VALUE self, VALUE field) {
595
+ struct cDataConverter_data *data;
596
+ struct cField_data *field_data;
597
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
598
+ TypedData_Get_Struct(field, struct cField_data, &cField_type, field_data);
599
+ data->__offset = Qnil;
600
+ data->__condition = Qnil;
601
+ data->__type = Qnil;
602
+ data->__length = Qnil;
603
+ data->__count = Qnil;
604
+ if (!RTEST(field_data->sequence)) {
605
+ data->__offset = cDataConverter_decode_seek_offset(self, field_data->offset, field_data->relative_offset);
606
+ if (!data->__offset)
607
+ return Qnil;
608
+ data->__condition = cDataConverter_decode_condition(self, field_data->condition);
609
+ if (!RTEST(data->__condition))
610
+ return Qnil;
611
+ data->__type = cDataConverter_decode_type(self, field_data->type);
612
+ data->__length = cDataConverter_decode_length(self, field_data->length);
613
+ }
614
+ data->__count = cDataConverter_decode_count(self, field_data->count);
615
+ return Qtrue;
616
+ }
617
+
618
+ /* def __decode_dynamic_conditions(field)
619
+ return true unless field.sequence?
620
+ @__offset = nil
621
+ @__condition = nil
622
+ @__type = nil
623
+ @__length = nil
624
+ @__offset = __decode_seek_offset(field.offset, field.relative_offset?)
625
+ return false if @__offset == false
626
+ @__condition = __decode_condition(field.condition)
627
+ return false unless @__condition
628
+ @__type = __decode_type(field.type)
629
+ @__length = __decode_length(field.length)
630
+ return true
631
+ end */
632
+
633
+ static inline VALUE cDataConverter_decode_dynamic_conditions(VALUE self, VALUE field) {
634
+ struct cDataConverter_data *data;
635
+ struct cField_data *field_data;
636
+ TypedData_Get_Struct(field, struct cField_data, &cField_type, field_data);
637
+ if (!RTEST(field_data->sequence))
638
+ return Qtrue;
639
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
640
+ data->__offset = Qnil;
641
+ data->__condition = Qnil;
642
+ data->__type = Qnil;
643
+ data->__length = Qnil;
644
+ data->__offset = cDataConverter_decode_seek_offset(self, field_data->offset, field_data->relative_offset);
645
+ if (!data->__offset)
646
+ return Qfalse;
647
+ data->__condition = cDataConverter_decode_condition(self, field_data->condition);
648
+ if (!RTEST(data->__condition))
649
+ return Qfalse;
650
+ data->__type = cDataConverter_decode_type(self, field_data->type);
651
+ data->__length = cDataConverter_decode_length(self, field_data->length);
652
+ return Qtrue;
653
+ }
654
+
655
+ /* def __restore_context
656
+ @__iterator = nil
657
+ @__type = nil
658
+ @__length = nil
659
+ @__count = nil
660
+ @__offset = nil
661
+ @__condition = nil
662
+ end */
663
+
664
+ static inline VALUE cDataConverter_restore_context(VALUE self) {
665
+ struct cDataConverter_data *data;
666
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
667
+ data->__iterator = Qnil;
668
+ data->__type = Qnil;
669
+ data->__length = Qnil;
670
+ data->__count = Qnil;
671
+ data->__offset = Qnil;
672
+ data->__condition = Qnil;
673
+ return Qnil;
674
+ }
675
+
676
+ /* def __convert_field(field)
677
+ __decode_static_conditions(field)
678
+ vs = @__count.times.collect do |it|
679
+ @__iterator = it
680
+ if __decode_dynamic_conditions(field)
681
+ @__type::convert(@__input, @__output, @__input_big, @__output_big, self, it, @__length)
682
+ else
683
+ nil
684
+ end
685
+ end
686
+ __restore_context
687
+ vs = vs.first unless field.count
688
+ vs
689
+ end */
690
+
691
+ static ID id_convert;
692
+
693
+ static inline VALUE cDataConverter_convert_field(VALUE self, VALUE field) {
694
+ VALUE res;
695
+ struct cDataConverter_data *data;
696
+ struct cField_data *field_data;
697
+ if (NIL_P(cDataConverter_decode_static_conditions(self, field)))
698
+ return Qnil;
699
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
700
+ TypedData_Get_Struct(field, struct cField_data, &cField_type, field_data);
701
+
702
+ if (RTEST(field_data->count)) {
703
+ long count = NUM2LONG(data->__count);
704
+ res = rb_ary_new_capa(count);
705
+
706
+ for (long i = 0; i < count; i++) {
707
+ data->__iterator = LONG2NUM(i);
708
+ if (RTEST(cDataConverter_decode_dynamic_conditions(self, field)))
709
+ rb_ary_store(res, i, rb_funcall(data->__type, id_convert, 7,
710
+ data->__input,
711
+ data->__output,
712
+ data->__input_big,
713
+ data->__output_big,
714
+ self,
715
+ data->__iterator,
716
+ data->__length));
717
+ else
718
+ rb_ary_store(res, i, Qnil);
719
+ }
720
+ } else {
721
+ data->__iterator = INT2FIX(0);
722
+ if (RTEST(cDataConverter_decode_dynamic_conditions(self, field)))
723
+ res = rb_funcall(data->__type, id_convert, 7,
724
+ data->__input,
725
+ data->__output,
726
+ data->__input_big,
727
+ data->__output_big,
728
+ self,
729
+ data->__iterator,
730
+ data->__length);
731
+ else
732
+ res = Qnil;
733
+ }
734
+
735
+ cDataConverter_restore_context(self);
736
+ return res;
737
+ }
738
+
739
+ /* def __load_field(field)
740
+ __decode_static_conditions(field)
741
+ vs = @__count.times.collect do |it|
742
+ @__iterator = it
743
+ if __decode_dynamic_conditions(field)
744
+ @__type::load(@__input, @__input_big, self, it, @__length)
745
+ else
746
+ nil
747
+ end
748
+ end
749
+ __restore_context
750
+ vs = vs.first unless field.count
751
+ vs
752
+ end */
753
+
754
+ static ID id_load;
755
+
756
+ static inline VALUE cDataConverter_load_field(VALUE self, VALUE field) {
757
+ VALUE res;
758
+ struct cDataConverter_data *data;
759
+ struct cField_data *field_data;
760
+ if (NIL_P(cDataConverter_decode_static_conditions(self, field)))
761
+ return Qnil;
762
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
763
+ TypedData_Get_Struct(field, struct cField_data, &cField_type, field_data);
764
+
765
+ if (RTEST(field_data->count)) {
766
+ long count = NUM2LONG(data->__count);
767
+ res = rb_ary_new_capa(count);
768
+
769
+ for (long i = 0; i < count; i++) {
770
+ data->__iterator = LONG2NUM(i);
771
+ if (RTEST(cDataConverter_decode_dynamic_conditions(self, field)))
772
+ rb_ary_store(res, i, rb_funcall(data->__type, id_load, 5,
773
+ data->__input,
774
+ data->__input_big,
775
+ self,
776
+ data->__iterator,
777
+ data->__length));
778
+ else
779
+ rb_ary_store(res, i, Qnil);
780
+ }
781
+ } else {
782
+ data->__iterator = INT2FIX(0);
783
+ if (RTEST(cDataConverter_decode_dynamic_conditions(self, field)))
784
+ res = rb_funcall(data->__type, id_load, 5,
785
+ data->__input,
786
+ data->__input_big,
787
+ self,
788
+ data->__iterator,
789
+ data->__length);
790
+ else
791
+ res = Qnil;
792
+ }
793
+ cDataConverter_restore_context(self);
794
+ return res;
795
+ }
796
+
797
+ /* def __dump_field(vs, field)
798
+ __decode_static_conditions(field)
799
+ vs = [vs] unless field.count
800
+ vs.each_with_index do |v, it|
801
+ @__iterator = it
802
+ if __decode_dynamic_conditions(field)
803
+ @__type::dump(v, @__output, @__output_big, self, it, @__length)
804
+ end
805
+ end
806
+ __restore_context
807
+ end */
808
+
809
+ static ID id_dump;
810
+
811
+ static inline VALUE cDataConverter_dump_field(VALUE self, VALUE values, VALUE field) {
812
+ struct cDataConverter_data *data;
813
+ struct cField_data *field_data;
814
+ if (NIL_P(cDataConverter_decode_static_conditions(self, field)))
815
+ return Qnil;
816
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
817
+ TypedData_Get_Struct(field, struct cField_data, &cField_type, field_data);
818
+
819
+ if (RTEST(field_data->count)) {
820
+ long count = RARRAY_LEN(values);
821
+
822
+ for (long i = 0; i < count; i++) {
823
+ data->__iterator = LONG2NUM(i);
824
+ if (RTEST(cDataConverter_decode_dynamic_conditions(self, field)))
825
+ rb_funcall(data->__type, id_dump, 6,
826
+ rb_ary_entry(values, i),
827
+ data->__output,
828
+ data->__output_big,
829
+ self,
830
+ data->__iterator,
831
+ data->__length);
832
+ }
833
+ } else {
834
+ data->__iterator = INT2FIX(0);
835
+ if (RTEST(cDataConverter_decode_dynamic_conditions(self, field)))
836
+ rb_funcall(data->__type, id_dump, 6,
837
+ values,
838
+ data->__output,
839
+ data->__output_big,
840
+ self,
841
+ data->__iterator,
842
+ data->__length);
843
+ }
844
+ cDataConverter_restore_context(self);
845
+ return Qnil;
846
+ }
847
+
848
+ /* def __shape_field(vs, kind, field)
849
+ __decode_static_conditions(field)
850
+ vs = [vs] unless field.count
851
+ vs = vs.each_with_index.collect do |v, it|
852
+ @__iterator = it
853
+ if __decode_dynamic_conditions(field)
854
+ sh = @__type::shape(v, @__cur_position, self, it, kind, @__length)
855
+ @__cur_position = sh.last + 1 if sh.last && sh.last >= 0
856
+ sh
857
+ end
858
+ end
859
+ __restore_context
860
+ vs = field.count ? kind.new(vs) : vs.first
861
+ vs
862
+ end */
863
+
864
+ static ID id_shape;
865
+
866
+ static inline VALUE cDataConverter_shape_field(
867
+ VALUE self,
868
+ VALUE values,
869
+ VALUE kind,
870
+ VALUE field)
871
+ {
872
+ VALUE res = Qnil;
873
+ struct cDataConverter_data *data;
874
+ struct cField_data *field_data;
875
+ if (NIL_P(cDataConverter_decode_static_conditions(self, field)))
876
+ return Qnil;
877
+ TypedData_Get_Struct(self, struct cDataConverter_data, &cDataConverter_type, data);
878
+ TypedData_Get_Struct(field, struct cField_data, &cField_type, field_data);
879
+
880
+ if (RTEST(field_data->count)) {
881
+ long count = RARRAY_LEN(values);
882
+ res = rb_ary_new_capa(count);
883
+
884
+ for (long i = 0; i < count; i++) {
885
+ data->__iterator = LONG2NUM(i);
886
+ if (RTEST(cDataConverter_decode_dynamic_conditions(self, field))) {
887
+ VALUE shape = rb_funcall(data->__type, id_shape, 6,
888
+ rb_ary_entry(values, i),
889
+ data->__cur_position,
890
+ self,
891
+ data->__iterator,
892
+ kind,
893
+ data->__length);
894
+ rb_ary_store(res, i, shape);
895
+ VALUE last = rb_funcall(shape, rb_intern("last"), 0);
896
+ if (RTEST(last)) {
897
+ ptrdiff_t pos = NUM2LL(last);
898
+ if (pos >= 0)
899
+ data->__cur_position = LL2NUM(pos + 1);
900
+ }
901
+ }
902
+ }
903
+ res = rb_class_new_instance(1, &res, kind);
904
+ } else {
905
+ data->__iterator = INT2FIX(0);
906
+ if (RTEST(cDataConverter_decode_dynamic_conditions(self, field))) {
907
+ res = rb_funcall(data->__type, id_shape, 6,
908
+ values,
909
+ data->__cur_position,
910
+ self,
911
+ data->__iterator,
912
+ kind,
913
+ data->__length);
914
+ VALUE last = rb_funcall(res, rb_intern("last"), 0);
915
+ if (RTEST(last)) {
916
+ ptrdiff_t pos = NUM2LL(last);
917
+ if (pos >= 0)
918
+ data->__cur_position = LL2NUM(pos + 1);
919
+ }
920
+ }
921
+ }
922
+ cDataConverter_restore_context(self);
923
+ return res;
924
+ }
925
+
926
+ /* def __load_fields
927
+ self.class.instance_variable_get(:@fields).each { |field|
928
+ begin
929
+ send("#{field.name}=", __load_field(field))
930
+ rescue
931
+ STDERR.puts "#{self.class}: #{field.name}(#{field.type})"
932
+ raise
933
+ end
934
+ }
935
+ self
936
+ end */
937
+
938
+ static ID id_fields;
939
+
940
+ struct fields_state {
941
+ VALUE self;
942
+ VALUE fields;
943
+ VALUE field;
944
+ };
945
+
946
+ static inline VALUE cDataConverter_fields_rescue(VALUE state_p, VALUE exception) {
947
+ struct fields_state *state = (struct fields_state *)state_p;
948
+ if (NIL_P(state->field)) {
949
+ struct cDataConverter_data *data;
950
+ TypedData_Get_Struct(state->self, struct cDataConverter_data, &cDataConverter_type, data);
951
+ if (!NIL_P(rb_ivar_get(mLibBin, rb_intern("@__output"))))
952
+ rb_funcall(rb_ivar_get(mLibBin, rb_intern("@__output")), rb_intern("print"), 6,
953
+ rb_obj_class(state->self),
954
+ rb_str_new_cstr(": could not load fields, index: "),
955
+ data->__index,
956
+ rb_str_new_cstr(", current position: "),
957
+ data->__cur_position,
958
+ rb_str_new_cstr("\n"));
959
+ } else {
960
+ struct cField_data *field_data;
961
+ TypedData_Get_Struct(state->field, struct cField_data, &cField_type, field_data);
962
+ if (!NIL_P(rb_ivar_get(mLibBin, rb_intern("@__output"))))
963
+ rb_funcall(rb_ivar_get(mLibBin, rb_intern("@__output")), rb_intern("print"), 6,
964
+ rb_obj_class(state->self),
965
+ rb_str_new_cstr(": "),
966
+ field_data->name,
967
+ rb_str_new_cstr("("),
968
+ field_data->type,
969
+ rb_str_new_cstr(")\n"));
970
+ }
971
+ rb_exc_raise(exception);
972
+ return state->self;
973
+ }
974
+
975
+ static inline VALUE cDataConverter_load_fields_wrapper(VALUE state_p) {
976
+ struct fields_state *state = (struct fields_state *)state_p;
977
+ state->fields = rb_ivar_get(rb_obj_class(state->self), id_fields);
978
+ for (long i = 0; i < RARRAY_LEN(state->fields); i++) {
979
+ state->field = rb_ary_entry(state->fields, i);
980
+ struct cField_data *field_data;
981
+ TypedData_Get_Struct(state->field, struct cField_data, &cField_type, field_data);
982
+ rb_funcall(state->self, field_data->setter, 1, cDataConverter_load_field(state->self, state->field));
983
+ }
984
+ return state->self;
985
+ }
986
+
987
+ static ID id___load_fields;
988
+
989
+ static inline VALUE cDataConverter_load_fields(VALUE self) {
990
+ struct fields_state state = {self, Qnil, Qnil};
991
+ rb_rescue(&cDataConverter_load_fields_wrapper, (VALUE)&state,
992
+ &cDataConverter_fields_rescue, (VALUE)&state);
993
+ return self;
994
+ }
995
+
996
+ /* def __dump_fields
997
+ self.class.instance_variable_get(:@fields).each { |field|
998
+ begin
999
+ __dump_field(send(field.name), field)
1000
+ rescue
1001
+ STDERR.puts "#{self.class}: #{field.name}(#{field.type})"
1002
+ raise
1003
+ end
1004
+ }
1005
+ self
1006
+ end */
1007
+
1008
+ static inline VALUE cDataConverter_dump_fields_wrapper(VALUE state_p) {
1009
+ struct fields_state *state = (struct fields_state *)state_p;
1010
+ state->fields = rb_ivar_get(rb_obj_class(state->self), id_fields);
1011
+ for (long i = 0; i < RARRAY_LEN(state->fields); i++) {
1012
+ state->field = rb_ary_entry(state->fields, i);
1013
+ struct cField_data *field_data;
1014
+ TypedData_Get_Struct(state->field, struct cField_data, &cField_type, field_data);
1015
+ cDataConverter_dump_field(state->self, rb_funcall(state->self, field_data->getter, 0), state->field);
1016
+ }
1017
+ return state->self;
1018
+ }
1019
+
1020
+ static ID id___dump_fields;
1021
+
1022
+ static inline VALUE cDataConverter_dump_fields(VALUE self) {
1023
+ struct fields_state state = {self, Qnil, Qnil};
1024
+ rb_rescue(&cDataConverter_dump_fields_wrapper, (VALUE)&state,
1025
+ &cDataConverter_fields_rescue, (VALUE)&state);
1026
+ return self;
1027
+ }
1028
+
1029
+ /* def __convert_fields
1030
+ self.class.instance_variable_get(:@fields).each { |field|
1031
+ begin
1032
+ send("#{field.name}=", __convert_field(field))
1033
+ rescue
1034
+ STDERR.puts "#{self.class}: #{field.name}(#{field.type})"
1035
+ raise
1036
+ end
1037
+ }
1038
+ self
1039
+ end */
1040
+
1041
+ static inline VALUE cDataConverter_convert_fields_wrapper(VALUE state_p) {
1042
+ struct fields_state *state = (struct fields_state *)state_p;
1043
+ state->fields = rb_ivar_get(rb_obj_class(state->self), id_fields);
1044
+ for (long i = 0; i < RARRAY_LEN(state->fields); i++) {
1045
+ state->field = rb_ary_entry(state->fields, i);
1046
+ struct cField_data *field_data;
1047
+ TypedData_Get_Struct(state->field, struct cField_data, &cField_type, field_data);
1048
+ rb_funcall(state->self, field_data->setter, 1, cDataConverter_convert_field(state->self, state->field));
1049
+ }
1050
+ return state->self;
1051
+ }
1052
+
1053
+ static ID id___convert_fields;
1054
+
1055
+ static inline VALUE cDataConverter_convert_fields(VALUE self) {
1056
+ struct fields_state state = {self, Qnil, Qnil};
1057
+ rb_rescue(&cDataConverter_convert_fields_wrapper, (VALUE)&state,
1058
+ &cDataConverter_fields_rescue, (VALUE)&state);
1059
+ return self;
1060
+ }
1061
+
1062
+ /* def __shape_fields
1063
+ members = {}
1064
+ self.class.instance_variable_get(:@fields).each { |field|
1065
+ begin
1066
+ members[field.name] = __shape_field(send(field.name), kind, field)
1067
+ rescue
1068
+ STDERR.puts "#{self.class}: #{field.name}(#{field.type})"
1069
+ raise
1070
+ end
1071
+ }
1072
+ return members
1073
+ end */
1074
+
1075
+ struct shape_fields_state {
1076
+ VALUE self;
1077
+ VALUE fields;
1078
+ VALUE field;
1079
+ VALUE kind;
1080
+ };
1081
+
1082
+ static inline VALUE cDataConverter_shape_fields_wrapper(VALUE state_p) {
1083
+ struct shape_fields_state *state = (struct shape_fields_state *)state_p;
1084
+ state->fields = rb_ivar_get(rb_obj_class(state->self), id_fields);
1085
+ VALUE members = rb_hash_new();
1086
+ for (long i = 0; i < RARRAY_LEN(state->fields); i++) {
1087
+ state->field = rb_ary_entry(state->fields, i);
1088
+ struct cField_data *field_data;
1089
+ TypedData_Get_Struct(state->field, struct cField_data, &cField_type, field_data);
1090
+ rb_hash_aset(members, ID2SYM(field_data->getter), cDataConverter_shape_field(state->self, rb_funcall(state->self, field_data->getter, 0), state->kind, state->field));
1091
+ }
1092
+ return members;
1093
+ }
1094
+
1095
+ static ID id___shape_fields;
1096
+
1097
+ static inline VALUE cDataConverter_shape_fields(VALUE self, VALUE kind) {
1098
+ struct shape_fields_state state = {self, Qnil, Qnil, kind};
1099
+ return rb_rescue(&cDataConverter_shape_fields_wrapper, (VALUE)&state,
1100
+ &cDataConverter_fields_rescue, (VALUE)&state);
1101
+ }
1102
+
1103
+ /* def __load(input, input_big, parent = nil, index = nil)
1104
+ __set_load_type(input, input_big, parent, index)
1105
+ __load_fields
1106
+ __unset_load_type
1107
+ self
1108
+ end */
1109
+
1110
+ static ID id___load;
1111
+
1112
+ static inline VALUE cDataConverter_load(int argc, VALUE *argv, VALUE self) {
1113
+ VALUE input;
1114
+ VALUE input_big;
1115
+ VALUE parent;
1116
+ VALUE index;
1117
+ rb_scan_args(argc, argv, "22", &input, &input_big, &parent, &index);
1118
+ cDataConverter_set_load_type(self, input, input_big, parent, index);
1119
+ rb_funcall(self, id___load_fields, 0);
1120
+ cDataConverter_unset_load_type(self);
1121
+ return self;
1122
+ }
1123
+
1124
+ /* def __dump(output, output_big, parent = nil, index = nil)
1125
+ __set_dump_type(output, output_big, parent, index)
1126
+ __dump_fields
1127
+ __unset_dump_type
1128
+ self
1129
+ end */
1130
+
1131
+ static ID id___dump;
1132
+
1133
+ static inline VALUE cDataConverter_dump(int argc, VALUE *argv, VALUE self) {
1134
+ VALUE output;
1135
+ VALUE output_big;
1136
+ VALUE parent;
1137
+ VALUE index;
1138
+ rb_scan_args(argc, argv, "22", &output, &output_big, &parent, &index);
1139
+ cDataConverter_set_dump_type(self, output, output_big, parent, index);
1140
+ rb_funcall(self, id___dump_fields, 0);
1141
+ cDataConverter_unset_dump_type(self);
1142
+ return self;
1143
+ }
1144
+
1145
+ /* def __convert(input, output, input_big, output_big, parent = nil, index = nil)
1146
+ __set_convert_type(input, output, input_big, output_big, parent, index)
1147
+ __convert_fields
1148
+ __unset_convert_type
1149
+ self
1150
+ end */
1151
+
1152
+ static ID id___convert;
1153
+
1154
+ static inline VALUE cDataConverter_convert(int argc, VALUE *argv, VALUE self) {
1155
+ VALUE input;
1156
+ VALUE output;
1157
+ VALUE input_big;
1158
+ VALUE output_big;
1159
+ VALUE parent;
1160
+ VALUE index;
1161
+ rb_scan_args(argc, argv, "42", &input, &output, &input_big, &output_big, &parent, &index);
1162
+ cDataConverter_set_convert_type(self, input, output, input_big, output_big, parent, index);
1163
+ rb_funcall(self, id___convert_fields, 0);
1164
+ cDataConverter_unset_convert_type(self);
1165
+ return self;
1166
+ }
1167
+
1168
+ /* def __shape(previous_offset = 0, parent = nil, index = nil, kind = DataShape)
1169
+ __set_size_type(previous_offset, parent, index)
1170
+ members = __shape_fields(kind)
1171
+ __unset_size_type
1172
+ return nil if members.values.compact.size <= 0
1173
+ kind::new(members)
1174
+ end */
1175
+
1176
+ static ID id___shape;
1177
+
1178
+ static inline VALUE cDataConverter_shape(int argc, VALUE *argv, VALUE self) {
1179
+ VALUE previous_offset;
1180
+ VALUE parent;
1181
+ VALUE index;
1182
+ VALUE kind;
1183
+ rb_scan_args(argc, argv, "04", &previous_offset, &parent, &index, &kind);
1184
+ if (NIL_P(previous_offset))
1185
+ previous_offset = INT2FIX(0);
1186
+ if (NIL_P(kind))
1187
+ kind = cDataShape;
1188
+ cDataConverter_set_size_type(self, previous_offset, parent, index);
1189
+ VALUE members = rb_funcall(self, id___shape_fields, 1, kind);
1190
+ cDataConverter_unset_size_type(self);
1191
+ if (RARRAY_LEN(rb_funcall(rb_funcall(members, rb_intern("values"), 0), rb_intern("compact"), 0)) <= 0)
1192
+ return Qnil;
1193
+ return rb_class_new_instance(1, &members, kind);
1194
+ }
1195
+
1196
+ /* def self.load(input, input_big = LibBin::default_big?, parent = nil, index = nil, length = nil)
1197
+ if length
1198
+ length.times.collect {
1199
+ h = self::new
1200
+ h.__load(input, input_big, parent, index)
1201
+ }
1202
+ else
1203
+ h = self::new
1204
+ h.__load(input, input_big, parent, index)
1205
+ end
1206
+ end */
1207
+
1208
+ static inline VALUE cDataConverter_singl_load(int argc, VALUE *argv, VALUE self) {
1209
+ VALUE input;
1210
+ VALUE input_big;
1211
+ VALUE parent;
1212
+ VALUE index;
1213
+ VALUE length;
1214
+ rb_scan_args(argc, argv, "14", &input, &input_big, &parent, &index, &length);
1215
+ if (NIL_P(input_big))
1216
+ input_big = rb_funcall(mLibBin, rb_intern("default_big?"), 0);
1217
+ VALUE res;
1218
+ if (!NIL_P(length)) {
1219
+ long l = NUM2LONG(length);
1220
+ res = rb_ary_new_capa(l);
1221
+ for (long i = 0; i < l; i++) {
1222
+ VALUE obj = rb_class_new_instance(0, NULL, self);
1223
+ rb_funcall(obj, id___load, 4, input, input_big, parent, index);
1224
+ rb_ary_store(res, i, obj);
1225
+ }
1226
+ return res;
1227
+ } else {
1228
+ res = rb_class_new_instance(0, NULL, self);
1229
+ rb_funcall(res, id___load, 4, input, input_big, parent, index);
1230
+ }
1231
+ return res;
1232
+ }
1233
+
1234
+ /* def self.dump(value, output, output_big = LibBin::default_big?, parent = nil, index = nil, length = nil)
1235
+ if length
1236
+ length.times.each { |i|
1237
+ value[i].__dump(output, output_big, parent, index)
1238
+ }
1239
+ value
1240
+ else
1241
+ value.__dump(output, output_big, parent, index)
1242
+ end
1243
+ end */
1244
+
1245
+ static inline VALUE cDataConverter_singl_dump(int argc, VALUE *argv, VALUE self) {
1246
+ VALUE value;
1247
+ VALUE output;
1248
+ VALUE output_big;
1249
+ VALUE parent;
1250
+ VALUE index;
1251
+ VALUE length;
1252
+ rb_scan_args(argc, argv, "24", &value, &output, &output_big, &parent, &index, &length);
1253
+ if (NIL_P(output_big))
1254
+ output_big = rb_funcall(mLibBin, rb_intern("default_big?"), 0);
1255
+ if (!NIL_P(length)) {
1256
+ long l = NUM2LONG(length);
1257
+ for (long i = 0; i < l; i++)
1258
+ rb_funcall(rb_ary_entry(value, i), id___dump, 4, output, output_big, parent, index);
1259
+ } else
1260
+ rb_funcall(value, id___dump, 4, output, output_big, parent, index);
1261
+ return value;
1262
+ }
1263
+
1264
+ /* def self.convert(input, output, input_big = LibBin::default_big?, output_big = !input_big, parent = nil, index = nil, length = nil)
1265
+ if length
1266
+ length.times.collect {
1267
+ h = self::new
1268
+ h.__convert(input, output, input_big, output_big, parent, index)
1269
+ }
1270
+ else
1271
+ h = self::new
1272
+ h.__convert(input, output, input_big, output_big, parent, index)
1273
+ end
1274
+ end */
1275
+
1276
+ static inline VALUE cDataConverter_singl_convert(int argc, VALUE *argv, VALUE self) {
1277
+ VALUE input;
1278
+ VALUE output;
1279
+ VALUE input_big;
1280
+ VALUE output_big;
1281
+ VALUE parent;
1282
+ VALUE index;
1283
+ VALUE length;
1284
+ rb_scan_args(argc, argv, "25", &input, &output, &input_big, &output_big, &parent, &index, &length);
1285
+ if (NIL_P(input_big))
1286
+ input_big = rb_funcall(mLibBin, rb_intern("default_big?"), 0);
1287
+ if (NIL_P(output_big))
1288
+ output_big = RTEST(input_big) ? Qfalse : Qtrue;
1289
+ VALUE res;
1290
+ if (!NIL_P(length)) {
1291
+ long l = NUM2LONG(length);
1292
+ res = rb_ary_new_capa(l);
1293
+ for (long i = 0; i < l; i++) {
1294
+ VALUE obj = rb_class_new_instance(0, NULL, self);
1295
+ rb_funcall(obj, id___convert, 6, input, output, input_big, output_big, parent, index);
1296
+ rb_ary_store(res, i, obj);
1297
+ }
1298
+ } else {
1299
+ res = rb_class_new_instance(0, NULL, self);
1300
+ rb_funcall(res, id___convert, 6, input, output, input_big, output_big, parent, index);
1301
+ }
1302
+ return res;
1303
+ }
1304
+
1305
+ /* def self.shape(value, previous_offset = 0, parent = nil, index = nil, kind = DataShape, length = nil)
1306
+ if length
1307
+ kind::new(length.times.collect { |i|
1308
+ value[i].__shape(previous_offset, parent, index, kind)
1309
+ })
1310
+ else
1311
+ value.__shape(previous_offset, parent, index, kind)
1312
+ end
1313
+ end */
1314
+
1315
+ static inline VALUE cDataConverter_singl_shape(int argc, VALUE *argv, VALUE self) {
1316
+ VALUE value;
1317
+ VALUE previous_offset;
1318
+ VALUE parent;
1319
+ VALUE index;
1320
+ VALUE kind;
1321
+ VALUE length;
1322
+ rb_scan_args(argc, argv, "15", &value, &previous_offset, &parent, &index, &kind, &length);
1323
+ if (NIL_P(previous_offset))
1324
+ previous_offset = INT2FIX(0);
1325
+ if (NIL_P(kind))
1326
+ kind = cDataShape;
1327
+ VALUE res;
1328
+ if (!NIL_P(length)) {
1329
+ long l = NUM2LONG(length);
1330
+ res = rb_ary_new_capa(l);
1331
+ for (long i = 0; i < l; i++)
1332
+ rb_ary_store(res, i, rb_funcall(rb_ary_entry(value, i), id___shape, 4, previous_offset, parent, index, kind));
1333
+ res = rb_class_new_instance(1, &res, kind);
1334
+ } else
1335
+ res = rb_funcall(value, id___shape, 4, previous_offset, parent, index, kind);
1336
+ return res;
1337
+ }
1338
+
1339
+ static void define_cDataConverter() {
1340
+ id_tell = rb_intern("tell");
1341
+ id_seek = rb_intern("seek");
1342
+ id_fields = rb_intern("@fields");
1343
+ id_instance_exec = rb_intern("instance_exec");
1344
+
1345
+ id___load_fields = rb_intern("__load_fields");
1346
+ id_load = rb_intern("load");
1347
+ id___load = rb_intern("__load");
1348
+
1349
+ id___dump_fields = rb_intern("__dump_fields");
1350
+ id_dump = rb_intern("dump");
1351
+ id___dump = rb_intern("__dump");
1352
+
1353
+ id___convert_fields = rb_intern("__convert_fields");
1354
+ id_convert = rb_intern("convert");
1355
+ id___convert = rb_intern("__convert");
1356
+
1357
+ id___shape_fields = rb_intern("__shape_fields");
1358
+ id_shape = rb_intern("shape");
1359
+ id___shape = rb_intern("__shape");
1360
+
1361
+ cDataConverter = rb_define_class_under(mLibBin, "DataConverter", rb_cObject);
1362
+ rb_define_alloc_func(cDataConverter, cDataConverter_alloc);
1363
+ rb_define_method(cDataConverter, "initialize", cDataConverter_initialize, 0);
1364
+ rb_define_method(cDataConverter, "__parent", cDataConverter_parent, 0);
1365
+ rb_define_method(cDataConverter, "__index", cDataConverter_index, 0);
1366
+ rb_define_method(cDataConverter, "__iterator", cDataConverter_iterator, 0);
1367
+ rb_define_method(cDataConverter, "__position", cDataConverter_position, 0);
1368
+ rb_define_method(cDataConverter, "__input", cDataConverter_input, 0);
1369
+ rb_define_method(cDataConverter, "__output", cDataConverter_output, 0);
1370
+ rb_define_method(cDataConverter, "__input_big", cDataConverter_input_big, 0);
1371
+ rb_define_method(cDataConverter, "__output_big", cDataConverter_output_big, 0);
1372
+
1373
+ rb_define_method(cDataConverter, "__set_convert_type", cDataConverter_set_convert_type, 6);
1374
+ rb_define_method(cDataConverter, "__unset_convert_type", cDataConverter_unset_convert_type, 0);
1375
+ rb_define_method(cDataConverter, "__set_size_type", cDataConverter_set_size_type, 3);
1376
+ rb_define_method(cDataConverter, "__unset_size_type", cDataConverter_unset_size_type, 0);
1377
+ rb_define_method(cDataConverter, "__set_load_type", cDataConverter_set_load_type, 4);
1378
+ rb_define_method(cDataConverter, "__unset_load_type", cDataConverter_unset_load_type, 0);
1379
+ rb_define_method(cDataConverter, "__set_dump_type", cDataConverter_set_dump_type, 4);
1380
+ rb_define_method(cDataConverter, "__unset_dump_type", cDataConverter_unset_dump_type, 0);
1381
+
1382
+ rb_define_method(cDataConverter, "__decode_expression", cDataConverter_decode_expression, 1);
1383
+ rb_define_method(cDataConverter, "__decode_seek_offset", cDataConverter_decode_seek_offset, 2);
1384
+ rb_define_method(cDataConverter, "__decode_condition", cDataConverter_decode_condition, 1);
1385
+ rb_define_method(cDataConverter, "__decode_count", cDataConverter_decode_count, 1);
1386
+ rb_define_method(cDataConverter, "__decode_type", cDataConverter_decode_type, 1);
1387
+ rb_define_method(cDataConverter, "__decode_length", cDataConverter_decode_length, 1);
1388
+ rb_define_method(cDataConverter, "__decode_static_conditions", cDataConverter_decode_static_conditions, 1);
1389
+ rb_define_method(cDataConverter, "__decode_dynamic_conditions", cDataConverter_decode_dynamic_conditions, 1);
1390
+
1391
+ rb_define_method(cDataConverter, "__restore_context", cDataConverter_restore_context, 0);
1392
+
1393
+ rb_define_method(cDataConverter, "__convert_field", cDataConverter_convert_field, 1);
1394
+ rb_define_method(cDataConverter, "__load_field", cDataConverter_load_field, 1);
1395
+ rb_define_method(cDataConverter, "__dump_field", cDataConverter_dump_field, 2);
1396
+ rb_define_method(cDataConverter, "__shape_field", cDataConverter_shape_field, 3);
1397
+
1398
+ rb_define_method(cDataConverter, "__load_fields", cDataConverter_load_fields, 0);
1399
+ rb_define_method(cDataConverter, "__dump_fields", cDataConverter_dump_fields, 0);
1400
+ rb_define_method(cDataConverter, "__convert_fields", cDataConverter_convert_fields, 0);
1401
+ rb_define_method(cDataConverter, "__shape_fields", cDataConverter_shape_fields, 1);
1402
+
1403
+ rb_define_method(cDataConverter, "__load", cDataConverter_load, -1);
1404
+ rb_define_method(cDataConverter, "__dump", cDataConverter_dump, -1);
1405
+ rb_define_method(cDataConverter, "__convert", cDataConverter_convert, -1);
1406
+ rb_define_method(cDataConverter, "__shape", cDataConverter_shape, -1);
1407
+
1408
+ rb_define_singleton_method(cDataConverter, "load", cDataConverter_singl_load, -1);
1409
+ rb_define_singleton_method(cDataConverter, "dump", cDataConverter_singl_dump, -1);
1410
+ rb_define_singleton_method(cDataConverter, "convert", cDataConverter_singl_convert, -1);
1411
+ rb_define_singleton_method(cDataConverter, "shape", cDataConverter_singl_shape, -1);
1412
+ }
1413
+
10
1414
  static VALUE pghalf_from_string_p(VALUE self, VALUE str, VALUE pack_str) {
11
- Check_Type(str, T_STRING);
12
- Check_Type(pack_str, T_STRING);
13
- VALUE arr = rb_funcall(str, rb_intern("unpack"), 1, pack_str);
14
- uint16_t val = NUM2USHORT(rb_funcall(arr, rb_intern("first"), 0));
15
- union float_u res;
1415
+ (void)self;
1416
+ Check_Type(str, T_STRING);
1417
+ Check_Type(pack_str, T_STRING);
1418
+ VALUE arr = rb_funcall(str, rb_intern("unpack"), 1, pack_str);
1419
+ uint16_t val = NUM2USHORT(rb_funcall(arr, rb_intern("first"), 0));
1420
+ union float_u res;
16
1421
 
17
- res.i = pghalf_to_float(val);
18
- return DBL2NUM(res.f);
1422
+ res.i = pghalf_to_float(val);
1423
+ return DBL2NUM(res.f);
19
1424
  }
20
1425
 
21
1426
  static VALUE half_from_string_p(VALUE self, VALUE str, VALUE pack_str) {
22
- Check_Type(str, T_STRING);
23
- Check_Type(pack_str, T_STRING);
24
- VALUE arr = rb_funcall(str, rb_intern("unpack"), 1, pack_str);
25
- uint16_t val = NUM2USHORT(rb_funcall(arr, rb_intern("first"), 0));
26
- union float_u res;
1427
+ (void)self;
1428
+ Check_Type(str, T_STRING);
1429
+ Check_Type(pack_str, T_STRING);
1430
+ VALUE arr = rb_funcall(str, rb_intern("unpack"), 1, pack_str);
1431
+ uint16_t val = NUM2USHORT(rb_funcall(arr, rb_intern("first"), 0));
1432
+ union float_u res;
27
1433
 
28
- res.i = half_to_float(val);
29
- return DBL2NUM(res.f);
1434
+ res.i = half_to_float(val);
1435
+ return DBL2NUM(res.f);
30
1436
  }
31
1437
 
32
1438
  static VALUE pghalf_to_string_p(VALUE self, VALUE number, VALUE pack_str) {
33
- Check_Type(number, T_FLOAT);
34
- union float_u val;
35
- uint16_t res;
1439
+ (void)self;
1440
+ Check_Type(number, T_FLOAT);
1441
+ union float_u val;
1442
+ uint16_t res;
36
1443
 
37
- val.f = NUM2DBL(number);
38
- res = pghalf_from_float(val.i);
39
- VALUE arr = rb_ary_new3(1, UINT2NUM(res) );
1444
+ val.f = NUM2DBL(number);
1445
+ res = pghalf_from_float(val.i);
1446
+ VALUE arr = rb_ary_new3(1, UINT2NUM(res) );
40
1447
 
41
- return rb_funcall(arr, rb_intern("pack"), 1, pack_str);
1448
+ return rb_funcall(arr, rb_intern("pack"), 1, pack_str);
42
1449
  }
43
1450
 
44
1451
  static VALUE half_to_string_p(VALUE self, VALUE number, VALUE pack_str) {
45
- Check_Type(number, T_FLOAT);
46
- union float_u val;
47
- uint16_t res;
1452
+ (void)self;
1453
+ Check_Type(number, T_FLOAT);
1454
+ union float_u val;
1455
+ uint16_t res;
48
1456
 
49
- val.f = NUM2DBL(number);
50
- res = half_from_float(val.i);
51
- VALUE arr = rb_ary_new3(1, UINT2NUM(res) );
1457
+ val.f = NUM2DBL(number);
1458
+ res = half_from_float(val.i);
1459
+ VALUE arr = rb_ary_new3(1, UINT2NUM(res) );
52
1460
 
53
- return rb_funcall(arr, rb_intern("pack"), 1, pack_str);
1461
+ return rb_funcall(arr, rb_intern("pack"), 1, pack_str);
54
1462
  }
55
1463
 
56
1464
  void Init_libbin_c() {
57
- ID id;
58
- VALUE mod;
59
- id = rb_intern("LibBin");
60
- mod = rb_const_get(rb_cObject, id);
61
- rb_define_module_function(mod, "half_from_string", half_from_string_p, 2);
62
- rb_define_module_function(mod, "half_to_string", half_to_string_p, 2);
63
- rb_define_module_function(mod, "pghalf_from_string", pghalf_from_string_p, 2);
64
- rb_define_module_function(mod, "pghalf_to_string", pghalf_to_string_p, 2);
1465
+ mLibBin = rb_define_module("LibBin");
1466
+ rb_define_module_function(mLibBin, "half_from_string", half_from_string_p, 2);
1467
+ rb_define_module_function(mLibBin, "half_to_string", half_to_string_p, 2);
1468
+ rb_define_module_function(mLibBin, "pghalf_from_string", pghalf_from_string_p, 2);
1469
+ rb_define_module_function(mLibBin, "pghalf_to_string", pghalf_to_string_p, 2);
1470
+ cDataShape = rb_define_class_under(mLibBin, "DataShape", rb_cObject);
1471
+ define_cField();
1472
+ define_cDataConverter();
1473
+ define_cScalar();
65
1474
  }