1 /*
2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
3 */
4
5 #include <linux/time.h>
6 #include <linux/reiserfs_fs.h>
7
8 // this contains item handlers for old item types: sd, direct,
9 // indirect, directory
10
11 /* and where are the comments? how about saying where we can find an
12 explanation of each item handler method? -Hans */
13
14 //////////////////////////////////////////////////////////////////////////////
15 // stat data functions
16 //
17 static int sd_bytes_number (struct item_head * ih, int block_size)
18 {
19 return 0;
20 }
21
22 static void sd_decrement_key (struct cpu_key * key)
23 {
24 key->on_disk_key.k_objectid --;
25 set_cpu_key_k_type (key, TYPE_ANY);
26 set_cpu_key_k_offset(key, (loff_t)(-1));
27 }
28
29 static int sd_is_left_mergeable (struct reiserfs_key * key, unsigned long bsize)
30 {
31 return 0;
32 }
33
34
35
36 static char * print_time (time_t t)
37 {
38 static char timebuf[256];
39
40 sprintf (timebuf, "%ld", t);
41 return timebuf;
42 }
43
44
45 static void sd_print_item (struct item_head * ih, char * item)
46 {
47 printk ("\tmode | size | nlinks | first direct | mtime\n");
48 if (stat_data_v1 (ih)) {
49 struct stat_data_v1 * sd = (struct stat_data_v1 *)item;
50
51 printk ("\t0%-6o | %6u | %2u | %d | %s\n", sd_v1_mode(sd),
52 sd_v1_size(sd), sd_v1_nlink(sd), sd_v1_first_direct_byte(sd),
53 print_time( sd_v1_mtime(sd) ) );
54 } else {
55 struct stat_data * sd = (struct stat_data *)item;
56
57 printk ("\t0%-6o | %6Lu | %2u | %d | %s\n", sd_v2_mode(sd),
58 (unsigned long long)sd_v2_size(sd), sd_v2_nlink(sd),
59 sd_v2_rdev(sd), print_time(sd_v2_mtime(sd)));
60 }
61 }
62
63 static void sd_check_item (struct item_head * ih, char * item)
64 {
65 // FIXME: type something here!
66 }
67
68
69 static int sd_create_vi (struct virtual_node * vn,
70 struct virtual_item * vi,
71 int is_affected,
72 int insert_size)
73 {
74 vi->vi_index = TYPE_STAT_DATA;
75 //vi->vi_type |= VI_TYPE_STAT_DATA;// not needed?
76 return 0;
77 }
78
79
80 static int sd_check_left (struct virtual_item * vi, int free,
81 int start_skip, int end_skip)
82 {
83 if (start_skip || end_skip)
84 BUG ();
85 return -1;
86 }
87
88
89 static int sd_check_right (struct virtual_item * vi, int free)
90 {
91 return -1;
92 }
93
94 static int sd_part_size (struct virtual_item * vi, int first, int count)
95 {
96 if (count)
97 BUG ();
98 return 0;
99 }
100
101 static int sd_unit_num (struct virtual_item * vi)
102 {
103 return vi->vi_item_len - IH_SIZE;
104 }
105
106
107 static void sd_print_vi (struct virtual_item * vi)
108 {
109 reiserfs_warning (NULL, "STATDATA, index %d, type 0x%x, %h",
110 vi->vi_index, vi->vi_type, vi->vi_ih);
111 }
112
113 static struct item_operations stat_data_ops = {
114 .bytes_number = sd_bytes_number,
115 .decrement_key = sd_decrement_key,
116 .is_left_mergeable = sd_is_left_mergeable,
117 .print_item = sd_print_item,
118 .check_item = sd_check_item,
119
120 .create_vi = sd_create_vi,
121 .check_left = sd_check_left,
122 .check_right = sd_check_right,
123 .part_size = sd_part_size,
124 .unit_num = sd_unit_num,
125 .print_vi = sd_print_vi
126 };
127
128
129
130 //////////////////////////////////////////////////////////////////////////////
131 // direct item functions
132 //
133 static int direct_bytes_number (struct item_head * ih, int block_size)
134 {
135 return ih_item_len(ih);
136 }
137
138
139 // FIXME: this should probably switch to indirect as well
140 static void direct_decrement_key (struct cpu_key * key)
141 {
142 cpu_key_k_offset_dec (key);
143 if (cpu_key_k_offset (key) == 0)
144 set_cpu_key_k_type (key, TYPE_STAT_DATA);
145 }
146
147
148 static int direct_is_left_mergeable (struct reiserfs_key * key, unsigned long bsize)
149 {
150 int version = le_key_version (key);
151 return ((le_key_k_offset (version, key) & (bsize - 1)) != 1);
152 }
153
154
155 static void direct_print_item (struct item_head * ih, char * item)
156 {
157 int j = 0;
158
159 // return;
160 printk ("\"");
161 while (j < ih_item_len(ih))
162 printk ("%c", item[j++]);
163 printk ("\"\n");
164 }
165
166
167 static void direct_check_item (struct item_head * ih, char * item)
168 {
169 // FIXME: type something here!
170 }
171
172
173 static int direct_create_vi (struct virtual_node * vn,
174 struct virtual_item * vi,
175 int is_affected,
176 int insert_size)
177 {
178 vi->vi_index = TYPE_DIRECT;
179 //vi->vi_type |= VI_TYPE_DIRECT;
180 return 0;
181 }
182
183 static int direct_check_left (struct virtual_item * vi, int free,
184 int start_skip, int end_skip)
185 {
186 int bytes;
187
188 bytes = free - free % 8;
189 return bytes ?: -1;
190 }
191
192
193 static int direct_check_right (struct virtual_item * vi, int free)
194 {
195 return direct_check_left (vi, free, 0, 0);
196 }
197
198 static int direct_part_size (struct virtual_item * vi, int first, int count)
199 {
200 return count;
201 }
202
203
204 static int direct_unit_num (struct virtual_item * vi)
205 {
206 return vi->vi_item_len - IH_SIZE;
207 }
208
209
210 static void direct_print_vi (struct virtual_item * vi)
211 {
212 reiserfs_warning (NULL, "DIRECT, index %d, type 0x%x, %h",
213 vi->vi_index, vi->vi_type, vi->vi_ih);
214 }
215
216 static struct item_operations direct_ops = {
217 .bytes_number = direct_bytes_number,
218 .decrement_key = direct_decrement_key,
219 .is_left_mergeable = direct_is_left_mergeable,
220 .print_item = direct_print_item,
221 .check_item = direct_check_item,
222
223 .create_vi = direct_create_vi,
224 .check_left = direct_check_left,
225 .check_right = direct_check_right,
226 .part_size = direct_part_size,
227 .unit_num = direct_unit_num,
228 .print_vi = direct_print_vi
229 };
230
231
232
233 //////////////////////////////////////////////////////////////////////////////
234 // indirect item functions
235 //
236
237 static int indirect_bytes_number (struct item_head * ih, int block_size)
238 {
239 return ih_item_len(ih) / UNFM_P_SIZE * block_size; //- get_ih_free_space (ih);
240 }
241
242
243 // decrease offset, if it becomes 0, change type to stat data
244 static void indirect_decrement_key (struct cpu_key * key)
245 {
246 cpu_key_k_offset_dec (key);
247 if (cpu_key_k_offset (key) == 0)
248 set_cpu_key_k_type (key, TYPE_STAT_DATA);
249 }
250
251
252 // if it is not first item of the body, then it is mergeable
253 static int indirect_is_left_mergeable (struct reiserfs_key * key, unsigned long bsize)
254 {
255 int version = le_key_version (key);
256 return (le_key_k_offset (version, key) != 1);
257 }
258
259
260 // printing of indirect item
261 static void start_new_sequence (__u32 * start, int * len, __u32 new)
262 {
263 *start = new;
264 *len = 1;
265 }
266
267
268 static int sequence_finished (__u32 start, int * len, __u32 new)
269 {
270 if (start == INT_MAX)
271 return 1;
272
273 if (start == 0 && new == 0) {
274 (*len) ++;
275 return 0;
276 }
277 if (start != 0 && (start + *len) == new) {
278 (*len) ++;
279 return 0;
280 }
281 return 1;
282 }
283
284 static void print_sequence (__u32 start, int len)
285 {
286 if (start == INT_MAX)
287 return;
288
289 if (len == 1)
290 printk (" %d", start);
291 else
292 printk (" %d(%d)", start, len);
293 }
294
295
296 static void indirect_print_item (struct item_head * ih, char * item)
297 {
298 int j;
299 __u32 * unp, prev = INT_MAX;
300 int num;
301
302 unp = (__u32 *)item;
303
304 if (ih_item_len(ih) % UNFM_P_SIZE)
305 reiserfs_warning (NULL, "indirect_print_item: invalid item len");
306
307 printk ("%d pointers\n[ ", (int)I_UNFM_NUM (ih));
308 for (j = 0; j < I_UNFM_NUM (ih); j ++) {
309 if (sequence_finished (prev, &num, get_block_num(unp, j))) {
310 print_sequence (prev, num);
311 start_new_sequence (&prev, &num, get_block_num(unp, j));
312 }
313 }
314 print_sequence (prev, num);
315 printk ("]\n");
316 }
317
318 static void indirect_check_item (struct item_head * ih, char * item)
319 {
320 // FIXME: type something here!
321 }
322
323
324 static int indirect_create_vi (struct virtual_node * vn,
325 struct virtual_item * vi,
326 int is_affected,
327 int insert_size)
328 {
329 vi->vi_index = TYPE_INDIRECT;
330 //vi->vi_type |= VI_TYPE_INDIRECT;
331 return 0;
332 }
333
334 static int indirect_check_left (struct virtual_item * vi, int free,
335 int start_skip, int end_skip)
336 {
337 int bytes;
338
339 bytes = free - free % UNFM_P_SIZE;
340 return bytes ?: -1;
341 }
342
343
344 static int indirect_check_right (struct virtual_item * vi, int free)
345 {
346 return indirect_check_left (vi, free, 0, 0);
347 }
348
349
350
351 // return size in bytes of 'units' units. If first == 0 - calculate from the head (left), otherwise - from tail (right)
352 static int indirect_part_size (struct virtual_item * vi, int first, int units)
353 {
354 // unit of indirect item is byte (yet)
355 return units;
356 }
357
358 static int indirect_unit_num (struct virtual_item * vi)
359 {
360 // unit of indirect item is byte (yet)
361 return vi->vi_item_len - IH_SIZE;
362 }
363
364 static void indirect_print_vi (struct virtual_item * vi)
365 {
366 reiserfs_warning (NULL, "INDIRECT, index %d, type 0x%x, %h",
367 vi->vi_index, vi->vi_type, vi->vi_ih);
368 }
369
370 static struct item_operations indirect_ops = {
371 .bytes_number = indirect_bytes_number,
372 .decrement_key = indirect_decrement_key,
373 .is_left_mergeable = indirect_is_left_mergeable,
374 .print_item = indirect_print_item,
375 .check_item = indirect_check_item,
376
377 .create_vi = indirect_create_vi,
378 .check_left = indirect_check_left,
379 .check_right = indirect_check_right,
380 .part_size = indirect_part_size,
381 .unit_num = indirect_unit_num,
382 .print_vi = indirect_print_vi
383 };
384
385
386 //////////////////////////////////////////////////////////////////////////////
387 // direntry functions
388 //
389
390
391 static int direntry_bytes_number (struct item_head * ih, int block_size)
392 {
393 reiserfs_warning (NULL, "vs-16090: direntry_bytes_number: "
394 "bytes number is asked for direntry");
395 return 0;
396 }
397
398 static void direntry_decrement_key (struct cpu_key * key)
399 {
400 cpu_key_k_offset_dec (key);
401 if (cpu_key_k_offset (key) == 0)
402 set_cpu_key_k_type (key, TYPE_STAT_DATA);
403 }
404
405
406 static int direntry_is_left_mergeable (struct reiserfs_key * key, unsigned long bsize)
407 {
408 if (le32_to_cpu (key->u.k_offset_v1.k_offset) == DOT_OFFSET)
409 return 0;
410 return 1;
411
412 }
413
414
415 static void direntry_print_item (struct item_head * ih, char * item)
416 {
417 int i;
418 int namelen;
419 struct reiserfs_de_head * deh;
420 char * name;
421 static char namebuf [80];
422
423
424 printk ("\n # %-15s%-30s%-15s%-15s%-15s\n", "Name", "Key of pointed object", "Hash", "Gen number", "Status");
425
426 deh = (struct reiserfs_de_head *)item;
427
428 for (i = 0; i < I_ENTRY_COUNT (ih); i ++, deh ++) {
429 namelen = (i ? (deh_location(deh - 1)) : ih_item_len(ih)) - deh_location(deh);
430 name = item + deh_location(deh);
431 if (name[namelen-1] == 0)
432 namelen = strlen (name);
433 namebuf[0] = '"';
434 if (namelen > sizeof (namebuf) - 3) {
435 strncpy (namebuf + 1, name, sizeof (namebuf) - 3);
436 namebuf[sizeof (namebuf) - 2] = '"';
437 namebuf[sizeof (namebuf) - 1] = 0;
438 } else {
439 memcpy (namebuf + 1, name, namelen);
440 namebuf[namelen + 1] = '"';
441 namebuf[namelen + 2] = 0;
442 }
443
444 printk ("%d: %-15s%-15d%-15d%-15Ld%-15Ld(%s)\n",
445 i, namebuf,
446 deh_dir_id(deh), deh_objectid(deh),
447 GET_HASH_VALUE (deh_offset (deh)), GET_GENERATION_NUMBER ((deh_offset (deh))),
448 (de_hidden (deh)) ? "HIDDEN" : "VISIBLE");
449 }
450 }
451
452
453 static void direntry_check_item (struct item_head * ih, char * item)
454 {
455 int i;
456 struct reiserfs_de_head * deh;
457
458 // FIXME: type something here!
459 deh = (struct reiserfs_de_head *)item;
460 for (i = 0; i < I_ENTRY_COUNT (ih); i ++, deh ++) {
461 ;
462 }
463 }
464
465
466
467 #define DIRENTRY_VI_FIRST_DIRENTRY_ITEM 1
468
469 /*
470 * function returns old entry number in directory item in real node
471 * using new entry number in virtual item in virtual node */
472 static inline int old_entry_num (int is_affected, int virtual_entry_num, int pos_in_item, int mode)
473 {
474 if ( mode == M_INSERT || mode == M_DELETE)
475 return virtual_entry_num;
476
477 if (!is_affected)
478 /* cut or paste is applied to another item */
479 return virtual_entry_num;
480
481 if (virtual_entry_num < pos_in_item)
482 return virtual_entry_num;
483
484 if (mode == M_CUT)
485 return virtual_entry_num + 1;
486
487 RFALSE( mode != M_PASTE || virtual_entry_num == 0,
488 "vs-8015: old_entry_num: mode must be M_PASTE (mode = \'%c\'", mode);
489
490 return virtual_entry_num - 1;
491 }
492
493
494
495
496 /* Create an array of sizes of directory entries for virtual
497 item. Return space used by an item. FIXME: no control over
498 consuming of space used by this item handler */
499 static int direntry_create_vi (struct virtual_node * vn,
500 struct virtual_item * vi,
501 int is_affected,
502 int insert_size)
503 {
504 struct direntry_uarea * dir_u = vi->vi_uarea;
505 int i, j;
506 int size = sizeof (struct direntry_uarea);
507 struct reiserfs_de_head * deh;
508
509 vi->vi_index = TYPE_DIRENTRY;
510
511 if (!(vi->vi_ih) || !vi->vi_item)
512 BUG ();
513
514
515 dir_u->flags = 0;
516 if (le_ih_k_offset (vi->vi_ih) == DOT_OFFSET)
517 dir_u->flags |= DIRENTRY_VI_FIRST_DIRENTRY_ITEM;
518
519 deh = (struct reiserfs_de_head *)(vi->vi_item);
520
521
522 /* virtual directory item have this amount of entry after */
523 dir_u->entry_count = ih_entry_count (vi->vi_ih) +
524 ((is_affected) ? ((vn->vn_mode == M_CUT) ? -1 :
525 (vn->vn_mode == M_PASTE ? 1 : 0)) : 0);
526
527 for (i = 0; i < dir_u->entry_count; i ++) {
528 j = old_entry_num (is_affected, i, vn->vn_pos_in_item, vn->vn_mode);
529 dir_u->entry_sizes[i] = (j ? deh_location( &(deh[j - 1]) ) :
530 ih_item_len (vi->vi_ih)) -
531 deh_location( &(deh[j])) + DEH_SIZE;
532 }
533
534 size += (dir_u->entry_count * sizeof (short));
535
536 /* set size of pasted entry */
537 if (is_affected && vn->vn_mode == M_PASTE)
538 dir_u->entry_sizes[vn->vn_pos_in_item] = insert_size;
539
540
541 #ifdef CONFIG_REISERFS_CHECK
542 /* compare total size of entries with item length */
543 {
544 int k, l;
545
546 l = 0;
547 for (k = 0; k < dir_u->entry_count; k ++)
548 l += dir_u->entry_sizes[k];
549
550 if (l + IH_SIZE != vi->vi_item_len +
551 ((is_affected && (vn->vn_mode == M_PASTE || vn->vn_mode == M_CUT)) ? insert_size : 0) ) {
552 reiserfs_panic (NULL, "vs-8025: set_entry_sizes: (mode==%c, insert_size==%d), invalid length of directory item",
553 vn->vn_mode, insert_size);
554 }
555 }
556 #endif
557
558 return size;
559
560
561 }
562
563
564 //
565 // return number of entries which may fit into specified amount of
566 // free space, or -1 if free space is not enough even for 1 entry
567 //
568 static int direntry_check_left (struct virtual_item * vi, int free,
569 int start_skip, int end_skip)
570 {
571 int i;
572 int entries = 0;
573 struct direntry_uarea * dir_u = vi->vi_uarea;
574
575 for (i = start_skip; i < dir_u->entry_count - end_skip; i ++) {
576 if (dir_u->entry_sizes[i] > free)
577 /* i-th entry doesn't fit into the remaining free space */
578 break;
579
580 free -= dir_u->entry_sizes[i];
581 entries ++;
582 }
583
584 if (entries == dir_u->entry_count) {
585 reiserfs_panic (NULL, "free space %d, entry_count %d\n", free, dir_u->entry_count);
586 }
587
588 /* "." and ".." can not be separated from each other */
589 if (start_skip == 0 && (dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM) && entries < 2)
590 entries = 0;
591
592 return entries ?: -1;
593 }
594
595
596 static int direntry_check_right (struct virtual_item * vi, int free)
597 {
598 int i;
599 int entries = 0;
600 struct direntry_uarea * dir_u = vi->vi_uarea;
601
602 for (i = dir_u->entry_count - 1; i >= 0; i --) {
603 if (dir_u->entry_sizes[i] > free)
604 /* i-th entry doesn't fit into the remaining free space */
605 break;
606
607 free -= dir_u->entry_sizes[i];
608 entries ++;
609 }
610 if (entries == dir_u->entry_count)
611 BUG ();
612
613 /* "." and ".." can not be separated from each other */
614 if ((dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM) && entries > dir_u->entry_count - 2)
615 entries = dir_u->entry_count - 2;
616
617 return entries ?: -1;
618 }
619
620
621 /* sum of entry sizes between from-th and to-th entries including both edges */
622 static int direntry_part_size (struct virtual_item * vi, int first, int count)
623 {
624 int i, retval;
625 int from, to;
626 struct direntry_uarea * dir_u = vi->vi_uarea;
627
628 retval = 0;
629 if (first == 0)
630 from = 0;
631 else
632 from = dir_u->entry_count - count;
633 to = from + count - 1;
634
635 for (i = from; i <= to; i ++)
636 retval += dir_u->entry_sizes[i];
637
638 return retval;
639 }
640
641 static int direntry_unit_num (struct virtual_item * vi)
642 {
643 struct direntry_uarea * dir_u = vi->vi_uarea;
644
645 return dir_u->entry_count;
646 }
647
648
649
650 static void direntry_print_vi (struct virtual_item * vi)
651 {
652 int i;
653 struct direntry_uarea * dir_u = vi->vi_uarea;
654
655 reiserfs_warning (NULL, "DIRENTRY, index %d, type 0x%x, %h, flags 0x%x",
656 vi->vi_index, vi->vi_type, vi->vi_ih, dir_u->flags);
657 printk ("%d entries: ", dir_u->entry_count);
658 for (i = 0; i < dir_u->entry_count; i ++)
659 printk ("%d ", dir_u->entry_sizes[i]);
660 printk ("\n");
661 }
662
663 static struct item_operations direntry_ops = {
664 .bytes_number = direntry_bytes_number,
665 .decrement_key = direntry_decrement_key,
666 .is_left_mergeable = direntry_is_left_mergeable,
667 .print_item = direntry_print_item,
668 .check_item = direntry_check_item,
669
670 .create_vi = direntry_create_vi,
671 .check_left = direntry_check_left,
672 .check_right = direntry_check_right,
673 .part_size = direntry_part_size,
674 .unit_num = direntry_unit_num,
675 .print_vi = direntry_print_vi
676 };
677
678
679 //////////////////////////////////////////////////////////////////////////////
680 // Error catching functions to catch errors caused by incorrect item types.
681 //
682 static int errcatch_bytes_number (struct item_head * ih, int block_size)
683 {
684 reiserfs_warning (NULL, "green-16001: Invalid item type observed, run fsck ASAP");
685 return 0;
686 }
687
688 static void errcatch_decrement_key (struct cpu_key * key)
689 {
690 reiserfs_warning (NULL, "green-16002: Invalid item type observed, run fsck ASAP");
691 }
692
693
694 static int errcatch_is_left_mergeable (struct reiserfs_key * key, unsigned long bsize)
695 {
696 reiserfs_warning (NULL, "green-16003: Invalid item type observed, run fsck ASAP");
697 return 0;
698 }
699
700
701 static void errcatch_print_item (struct item_head * ih, char * item)
702 {
703 reiserfs_warning (NULL, "green-16004: Invalid item type observed, run fsck ASAP");
704 }
705
706
707 static void errcatch_check_item (struct item_head * ih, char * item)
708 {
709 reiserfs_warning (NULL, "green-16005: Invalid item type observed, run fsck ASAP");
710 }
711
712 static int errcatch_create_vi (struct virtual_node * vn,
713 struct virtual_item * vi,
714 int is_affected,
715 int insert_size)
716 {
717 reiserfs_warning (NULL, "green-16006: Invalid item type observed, run fsck ASAP");
718 return 0; // We might return -1 here as well, but it won't help as create_virtual_node() from where
719 // this operation is called from is of return type void.
720 }
721
722 static int errcatch_check_left (struct virtual_item * vi, int free,
723 int start_skip, int end_skip)
724 {
725 reiserfs_warning (NULL, "green-16007: Invalid item type observed, run fsck ASAP");
726 return -1;
727 }
728
729
730 static int errcatch_check_right (struct virtual_item * vi, int free)
731 {
732 reiserfs_warning (NULL, "green-16008: Invalid item type observed, run fsck ASAP");
733 return -1;
734 }
735
736 static int errcatch_part_size (struct virtual_item * vi, int first, int count)
737 {
738 reiserfs_warning (NULL, "green-16009: Invalid item type observed, run fsck ASAP");
739 return 0;
740 }
741
742 static int errcatch_unit_num (struct virtual_item * vi)
743 {
744 reiserfs_warning (NULL, "green-16010: Invalid item type observed, run fsck ASAP");
745 return 0;
746 }
747
748 static void errcatch_print_vi (struct virtual_item * vi)
749 {
750 reiserfs_warning (NULL, "green-16011: Invalid item type observed, run fsck ASAP");
751 }
752
753 static struct item_operations errcatch_ops = {
754 errcatch_bytes_number,
755 errcatch_decrement_key,
756 errcatch_is_left_mergeable,
757 errcatch_print_item,
758 errcatch_check_item,
759
760 errcatch_create_vi,
761 errcatch_check_left,
762 errcatch_check_right,
763 errcatch_part_size,
764 errcatch_unit_num,
765 errcatch_print_vi
766 };
767
768
769
770 //////////////////////////////////////////////////////////////////////////////
771 //
772 //
773 #if ! (TYPE_STAT_DATA == 0 && TYPE_INDIRECT == 1 && TYPE_DIRECT == 2 && TYPE_DIRENTRY == 3)
774 do not compile
775 #endif
776
777 struct item_operations * item_ops [TYPE_ANY + 1] = {
778 &stat_data_ops,
779 &indirect_ops,
780 &direct_ops,
781 &direntry_ops,
782 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
783 &errcatch_ops /* This is to catch errors with invalid type (15th entry for TYPE_ANY) */
784 };
785
786
787
788
789
|
This page was automatically generated by the
LXR engine.
|