Cleanup: comments (long lines) in blenlib
[blender.git] / source / blender / blenlib / intern / listbase.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bli
22  *
23  * Manipulations on double-linked list (#ListBase structs).
24  *
25  * For single linked lists see 'BLI_linklist.h'
26  */
27
28 #include <string.h>
29 #include <stdlib.h>
30
31 #include "MEM_guardedalloc.h"
32
33 #include "DNA_listBase.h"
34
35 #include "BLI_listbase.h"
36
37 #include "BLI_strict_flags.h"
38
39 /* implementation */
40
41 /**
42  * moves the entire contents of \a src onto the end of \a dst.
43  */
44 void BLI_movelisttolist(ListBase *dst, ListBase *src)
45 {
46   if (src->first == NULL) {
47     return;
48   }
49
50   if (dst->first == NULL) {
51     dst->first = src->first;
52     dst->last = src->last;
53   }
54   else {
55     ((Link *)dst->last)->next = src->first;
56     ((Link *)src->first)->prev = dst->last;
57     dst->last = src->last;
58   }
59   src->first = src->last = NULL;
60 }
61
62 /**
63  * moves the entire contents of \a src at the beginning of \a dst.
64  */
65 void BLI_movelisttolist_reverse(ListBase *dst, ListBase *src)
66 {
67   if (src->first == NULL) {
68     return;
69   }
70
71   if (dst->first == NULL) {
72     dst->first = src->first;
73     dst->last = src->last;
74   }
75   else {
76     ((Link *)src->last)->next = dst->first;
77     ((Link *)dst->first)->prev = src->last;
78     dst->first = src->first;
79   }
80
81   src->first = src->last = NULL;
82 }
83
84 /**
85  * Prepends \a vlink (assumed to begin with a Link) onto listbase.
86  */
87 void BLI_addhead(ListBase *listbase, void *vlink)
88 {
89   Link *link = vlink;
90
91   if (link == NULL) {
92     return;
93   }
94
95   link->next = listbase->first;
96   link->prev = NULL;
97
98   if (listbase->first) {
99     ((Link *)listbase->first)->prev = link;
100   }
101   if (listbase->last == NULL) {
102     listbase->last = link;
103   }
104   listbase->first = link;
105 }
106
107 /**
108  * Appends \a vlink (assumed to begin with a Link) onto listbase.
109  */
110 void BLI_addtail(ListBase *listbase, void *vlink)
111 {
112   Link *link = vlink;
113
114   if (link == NULL) {
115     return;
116   }
117
118   link->next = NULL;
119   link->prev = listbase->last;
120
121   if (listbase->last) {
122     ((Link *)listbase->last)->next = link;
123   }
124   if (listbase->first == NULL) {
125     listbase->first = link;
126   }
127   listbase->last = link;
128 }
129
130 /**
131  * Removes \a vlink from \a listbase. Assumes it is linked into there!
132  */
133 void BLI_remlink(ListBase *listbase, void *vlink)
134 {
135   Link *link = vlink;
136
137   if (link == NULL) {
138     return;
139   }
140
141   if (link->next) {
142     link->next->prev = link->prev;
143   }
144   if (link->prev) {
145     link->prev->next = link->next;
146   }
147
148   if (listbase->last == link) {
149     listbase->last = link->prev;
150   }
151   if (listbase->first == link) {
152     listbase->first = link->next;
153   }
154 }
155
156 /**
157  * Checks that \a vlink is linked into listbase, removing it from there if so.
158  */
159 bool BLI_remlink_safe(ListBase *listbase, void *vlink)
160 {
161   if (BLI_findindex(listbase, vlink) != -1) {
162     BLI_remlink(listbase, vlink);
163     return true;
164   }
165   else {
166     return false;
167   }
168 }
169
170 /**
171  * Swaps \a vlinka and \a vlinkb in the list. Assumes they are both already in the list!
172  */
173 void BLI_listbase_swaplinks(ListBase *listbase, void *vlinka, void *vlinkb)
174 {
175   Link *linka = vlinka;
176   Link *linkb = vlinkb;
177
178   if (!linka || !linkb) {
179     return;
180   }
181
182   if (linkb->next == linka) {
183     SWAP(Link *, linka, linkb);
184   }
185
186   if (linka->next == linkb) {
187     linka->next = linkb->next;
188     linkb->prev = linka->prev;
189     linka->prev = linkb;
190     linkb->next = linka;
191   }
192   else { /* Non-contiguous items, we can safely swap. */
193     SWAP(Link *, linka->prev, linkb->prev);
194     SWAP(Link *, linka->next, linkb->next);
195   }
196
197   /* Update neighbors of linka and linkb. */
198   if (linka->prev) {
199     linka->prev->next = linka;
200   }
201   if (linka->next) {
202     linka->next->prev = linka;
203   }
204   if (linkb->prev) {
205     linkb->prev->next = linkb;
206   }
207   if (linkb->next) {
208     linkb->next->prev = linkb;
209   }
210
211   if (listbase->last == linka) {
212     listbase->last = linkb;
213   }
214   else if (listbase->last == linkb) {
215     listbase->last = linka;
216   }
217
218   if (listbase->first == linka) {
219     listbase->first = linkb;
220   }
221   else if (listbase->first == linkb) {
222     listbase->first = linka;
223   }
224 }
225
226 /**
227  * Swaps \a vlinka and \a vlinkb from their respective lists.
228  * Assumes they are both already in their lista!
229  */
230 void BLI_listbases_swaplinks(ListBase *listbasea, ListBase *listbaseb, void *vlinka, void *vlinkb)
231 {
232   Link *linka = vlinka;
233   Link *linkb = vlinkb;
234   Link linkc = {NULL};
235
236   if (!linka || !linkb) {
237     return;
238   }
239
240   /* Temporary link to use as placeholder of the links positions */
241   BLI_insertlinkafter(listbasea, linka, &linkc);
242
243   /* Bring linka into linkb position */
244   BLI_remlink(listbasea, linka);
245   BLI_insertlinkafter(listbaseb, linkb, linka);
246
247   /* Bring linkb into linka position */
248   BLI_remlink(listbaseb, linkb);
249   BLI_insertlinkafter(listbasea, &linkc, linkb);
250
251   /* Remove temporary link */
252   BLI_remlink(listbasea, &linkc);
253 }
254
255 /**
256  * Removes the head from \a listbase and returns it.
257  */
258 void *BLI_pophead(ListBase *listbase)
259 {
260   Link *link;
261   if ((link = listbase->first)) {
262     BLI_remlink(listbase, link);
263   }
264   return link;
265 }
266
267 /**
268  * Removes the tail from \a listbase and returns it.
269  */
270 void *BLI_poptail(ListBase *listbase)
271 {
272   Link *link;
273   if ((link = listbase->last)) {
274     BLI_remlink(listbase, link);
275   }
276   return link;
277 }
278
279 /**
280  * Removes \a vlink from listbase and disposes of it. Assumes it is linked into there!
281  */
282 void BLI_freelinkN(ListBase *listbase, void *vlink)
283 {
284   Link *link = vlink;
285
286   if (link == NULL) {
287     return;
288   }
289
290   BLI_remlink(listbase, link);
291   MEM_freeN(link);
292 }
293
294 /**
295  * Assigns all #Link.prev pointers from #Link.next
296  */
297 static void listbase_double_from_single(Link *iter, ListBase *listbase)
298 {
299   Link *prev = NULL;
300   listbase->first = iter;
301   do {
302     iter->prev = prev;
303     prev = iter;
304   } while ((iter = iter->next));
305   listbase->last = prev;
306 }
307
308 #define SORT_IMPL_LINKTYPE Link
309
310 /* regular call */
311 #define SORT_IMPL_FUNC listbase_sort_fn
312 #include "list_sort_impl.h"
313 #undef SORT_IMPL_FUNC
314
315 /* reentrant call */
316 #define SORT_IMPL_USE_THUNK
317 #define SORT_IMPL_FUNC listbase_sort_fn_r
318 #include "list_sort_impl.h"
319 #undef SORT_IMPL_FUNC
320 #undef SORT_IMPL_USE_THUNK
321
322 #undef SORT_IMPL_LINKTYPE
323
324 /**
325  * Sorts the elements of listbase into the order defined by cmp
326  * (which should return 1 if its first arg should come after its second arg).
327  * This uses insertion sort, so NOT ok for large list.
328  */
329 void BLI_listbase_sort(ListBase *listbase, int (*cmp)(const void *, const void *))
330 {
331   if (listbase->first != listbase->last) {
332     Link *head = listbase->first;
333     head = listbase_sort_fn(head, cmp);
334     listbase_double_from_single(head, listbase);
335   }
336 }
337
338 void BLI_listbase_sort_r(ListBase *listbase,
339                          int (*cmp)(void *, const void *, const void *),
340                          void *thunk)
341 {
342   if (listbase->first != listbase->last) {
343     Link *head = listbase->first;
344     head = listbase_sort_fn_r(head, cmp, thunk);
345     listbase_double_from_single(head, listbase);
346   }
347 }
348
349 /**
350  * Inserts \a vnewlink immediately following \a vprevlink in \a listbase.
351  * Or, if \a vprevlink is NULL, puts \a vnewlink at the front of the list.
352  */
353 void BLI_insertlinkafter(ListBase *listbase, void *vprevlink, void *vnewlink)
354 {
355   Link *prevlink = vprevlink;
356   Link *newlink = vnewlink;
357
358   /* newlink before nextlink */
359   if (newlink == NULL) {
360     return;
361   }
362
363   /* empty list */
364   if (listbase->first == NULL) {
365     listbase->first = newlink;
366     listbase->last = newlink;
367     return;
368   }
369
370   /* insert at head of list */
371   if (prevlink == NULL) {
372     newlink->prev = NULL;
373     newlink->next = listbase->first;
374     newlink->next->prev = newlink;
375     listbase->first = newlink;
376     return;
377   }
378
379   /* at end of list */
380   if (listbase->last == prevlink) {
381     listbase->last = newlink;
382   }
383
384   newlink->next = prevlink->next;
385   newlink->prev = prevlink;
386   prevlink->next = newlink;
387   if (newlink->next) {
388     newlink->next->prev = newlink;
389   }
390 }
391
392 /**
393  * Inserts \a vnewlink immediately preceding \a vnextlink in listbase.
394  * Or, if \a vnextlink is NULL, puts \a vnewlink at the end of the list.
395  */
396 void BLI_insertlinkbefore(ListBase *listbase, void *vnextlink, void *vnewlink)
397 {
398   Link *nextlink = vnextlink;
399   Link *newlink = vnewlink;
400
401   /* newlink before nextlink */
402   if (newlink == NULL) {
403     return;
404   }
405
406   /* empty list */
407   if (listbase->first == NULL) {
408     listbase->first = newlink;
409     listbase->last = newlink;
410     return;
411   }
412
413   /* insert at end of list */
414   if (nextlink == NULL) {
415     newlink->prev = listbase->last;
416     newlink->next = NULL;
417     ((Link *)listbase->last)->next = newlink;
418     listbase->last = newlink;
419     return;
420   }
421
422   /* at beginning of list */
423   if (listbase->first == nextlink) {
424     listbase->first = newlink;
425   }
426
427   newlink->next = nextlink;
428   newlink->prev = nextlink->prev;
429   nextlink->prev = newlink;
430   if (newlink->prev) {
431     newlink->prev->next = newlink;
432   }
433 }
434
435 /**
436  * Insert a link in place of another, without changing it's position in the list.
437  *
438  * Puts `vnewlink` in the position of `vreplacelink`, removing `vreplacelink`.
439  * - `vreplacelink` *must* be in the list.
440  * - `vnewlink` *must not* be in the list.
441  */
442 void BLI_insertlinkreplace(ListBase *listbase, void *vreplacelink, void *vnewlink)
443 {
444   Link *l_old = vreplacelink;
445   Link *l_new = vnewlink;
446
447   /* update adjacent links */
448   if (l_old->next != NULL) {
449     l_old->next->prev = l_new;
450   }
451   if (l_old->prev != NULL) {
452     l_old->prev->next = l_new;
453   }
454
455   /* set direct links */
456   l_new->next = l_old->next;
457   l_new->prev = l_old->prev;
458
459   /* update list */
460   if (listbase->first == l_old) {
461     listbase->first = l_new;
462   }
463   if (listbase->last == l_old) {
464     listbase->last = l_new;
465   }
466 }
467
468 /**
469  * Reinsert \a vlink relative to its current position but offset by \a step. Doesn't move
470  * item if new position would exceed list (could optionally move to head/tail).
471  *
472  * \param step: Absolute value defines step size, sign defines direction. E.g pass -1
473  *              to move \a vlink before previous, or 1 to move behind next.
474  * \return If position of \a vlink has changed.
475  */
476 bool BLI_listbase_link_move(ListBase *listbase, void *vlink, int step)
477 {
478   Link *link = vlink;
479   Link *hook = link;
480   const bool is_up = step < 0;
481
482   if (step == 0) {
483     return false;
484   }
485   BLI_assert(BLI_findindex(listbase, link) != -1);
486
487   /* find link to insert before/after */
488   for (int i = 0; i < ABS(step); i++) {
489     hook = is_up ? hook->prev : hook->next;
490     if (!hook) {
491       return false;
492     }
493   }
494
495   /* reinsert link */
496   BLI_remlink(listbase, vlink);
497   if (is_up) {
498     BLI_insertlinkbefore(listbase, hook, vlink);
499   }
500   else {
501     BLI_insertlinkafter(listbase, hook, vlink);
502   }
503   return true;
504 }
505
506 /**
507  * Removes and disposes of the entire contents of listbase using direct free(3).
508  */
509 void BLI_freelist(ListBase *listbase)
510 {
511   Link *link, *next;
512
513   link = listbase->first;
514   while (link) {
515     next = link->next;
516     free(link);
517     link = next;
518   }
519
520   BLI_listbase_clear(listbase);
521 }
522
523 /**
524  * Removes and disposes of the entire contents of \a listbase using guardedalloc.
525  */
526 void BLI_freelistN(ListBase *listbase)
527 {
528   Link *link, *next;
529
530   link = listbase->first;
531   while (link) {
532     next = link->next;
533     MEM_freeN(link);
534     link = next;
535   }
536
537   BLI_listbase_clear(listbase);
538 }
539
540 /**
541  * Returns the number of elements in \a listbase, up until (and including count_max)
542  *
543  * \note Use to avoid redundant looping.
544  */
545 int BLI_listbase_count_at_most(const ListBase *listbase, const int count_max)
546 {
547   Link *link;
548   int count = 0;
549
550   for (link = listbase->first; link && count != count_max; link = link->next) {
551     count++;
552   }
553
554   return count;
555 }
556
557 /**
558  * Returns the number of elements in \a listbase.
559  */
560 int BLI_listbase_count(const ListBase *listbase)
561 {
562   Link *link;
563   int count = 0;
564
565   for (link = listbase->first; link; link = link->next) {
566     count++;
567   }
568
569   return count;
570 }
571
572 /**
573  * Returns the nth element of \a listbase, numbering from 0.
574  */
575 void *BLI_findlink(const ListBase *listbase, int number)
576 {
577   Link *link = NULL;
578
579   if (number >= 0) {
580     link = listbase->first;
581     while (link != NULL && number != 0) {
582       number--;
583       link = link->next;
584     }
585   }
586
587   return link;
588 }
589
590 /**
591  * Returns the nth-last element of \a listbase, numbering from 0.
592  */
593 void *BLI_rfindlink(const ListBase *listbase, int number)
594 {
595   Link *link = NULL;
596
597   if (number >= 0) {
598     link = listbase->last;
599     while (link != NULL && number != 0) {
600       number--;
601       link = link->prev;
602     }
603   }
604
605   return link;
606 }
607
608 /**
609  * Returns the position of \a vlink within \a listbase, numbering from 0, or -1 if not found.
610  */
611 int BLI_findindex(const ListBase *listbase, const void *vlink)
612 {
613   Link *link = NULL;
614   int number = 0;
615
616   if (vlink == NULL) {
617     return -1;
618   }
619
620   link = listbase->first;
621   while (link) {
622     if (link == vlink) {
623       return number;
624     }
625
626     number++;
627     link = link->next;
628   }
629
630   return -1;
631 }
632
633 /**
634  * Finds the first element of \a listbase which contains the null-terminated
635  * string \a id at the specified offset, returning NULL if not found.
636  */
637 void *BLI_findstring(const ListBase *listbase, const char *id, const int offset)
638 {
639   Link *link = NULL;
640   const char *id_iter;
641
642   if (id == NULL) {
643     return NULL;
644   }
645
646   for (link = listbase->first; link; link = link->next) {
647     id_iter = ((const char *)link) + offset;
648
649     if (id[0] == id_iter[0] && STREQ(id, id_iter)) {
650       return link;
651     }
652   }
653
654   return NULL;
655 }
656 /* same as above but find reverse */
657 /**
658  * Finds the last element of \a listbase which contains the
659  * null-terminated string \a id at the specified offset, returning NULL if not found.
660  */
661 void *BLI_rfindstring(const ListBase *listbase, const char *id, const int offset)
662 {
663   Link *link = NULL;
664   const char *id_iter;
665
666   for (link = listbase->last; link; link = link->prev) {
667     id_iter = ((const char *)link) + offset;
668
669     if (id[0] == id_iter[0] && STREQ(id, id_iter)) {
670       return link;
671     }
672   }
673
674   return NULL;
675 }
676
677 /**
678  * Finds the first element of \a listbase which contains a pointer to the
679  * null-terminated string \a id at the specified offset, returning NULL if not found.
680  */
681 void *BLI_findstring_ptr(const ListBase *listbase, const char *id, const int offset)
682 {
683   Link *link = NULL;
684   const char *id_iter;
685
686   for (link = listbase->first; link; link = link->next) {
687     /* exact copy of BLI_findstring(), except for this line */
688     id_iter = *((const char **)(((const char *)link) + offset));
689
690     if (id[0] == id_iter[0] && STREQ(id, id_iter)) {
691       return link;
692     }
693   }
694
695   return NULL;
696 }
697 /* same as above but find reverse */
698 /**
699  * Finds the last element of \a listbase which contains a pointer to the
700  * null-terminated string \a id at the specified offset, returning NULL if not found.
701  */
702 void *BLI_rfindstring_ptr(const ListBase *listbase, const char *id, const int offset)
703 {
704   Link *link = NULL;
705   const char *id_iter;
706
707   for (link = listbase->last; link; link = link->prev) {
708     /* exact copy of BLI_rfindstring(), except for this line */
709     id_iter = *((const char **)(((const char *)link) + offset));
710
711     if (id[0] == id_iter[0] && STREQ(id, id_iter)) {
712       return link;
713     }
714   }
715
716   return NULL;
717 }
718
719 /**
720  * Finds the first element of listbase which contains the specified pointer value
721  * at the specified offset, returning NULL if not found.
722  */
723 void *BLI_findptr(const ListBase *listbase, const void *ptr, const int offset)
724 {
725   Link *link = NULL;
726   const void *ptr_iter;
727
728   for (link = listbase->first; link; link = link->next) {
729     /* exact copy of BLI_findstring(), except for this line */
730     ptr_iter = *((const void **)(((const char *)link) + offset));
731
732     if (ptr == ptr_iter) {
733       return link;
734     }
735   }
736
737   return NULL;
738 }
739 /* same as above but find reverse */
740 /**
741  * Finds the last element of listbase which contains the specified pointer value
742  * at the specified offset, returning NULL if not found.
743  */
744 void *BLI_rfindptr(const ListBase *listbase, const void *ptr, const int offset)
745 {
746   Link *link = NULL;
747   const void *ptr_iter;
748
749   for (link = listbase->last; link; link = link->prev) {
750     /* exact copy of BLI_rfindstring(), except for this line */
751     ptr_iter = *((const void **)(((const char *)link) + offset));
752
753     if (ptr == ptr_iter) {
754       return link;
755     }
756   }
757
758   return NULL;
759 }
760
761 /**
762  * Finds the first element of listbase which contains the specified bytes
763  * at the specified offset, returning NULL if not found.
764  */
765 void *BLI_listbase_bytes_find(const ListBase *listbase,
766                               const void *bytes,
767                               const size_t bytes_size,
768                               const int offset)
769 {
770   Link *link = NULL;
771   const void *ptr_iter;
772
773   for (link = listbase->first; link; link = link->next) {
774     ptr_iter = (const void *)(((const char *)link) + offset);
775
776     if (memcmp(bytes, ptr_iter, bytes_size) == 0) {
777       return link;
778     }
779   }
780
781   return NULL;
782 }
783 /* same as above but find reverse */
784 /**
785  * Finds the last element of listbase which contains the specified bytes
786  * at the specified offset, returning NULL if not found.
787  */
788 void *BLI_listbase_bytes_rfind(const ListBase *listbase,
789                                const void *bytes,
790                                const size_t bytes_size,
791                                const int offset)
792 {
793   Link *link = NULL;
794   const void *ptr_iter;
795
796   for (link = listbase->last; link; link = link->prev) {
797     ptr_iter = (const void *)(((const char *)link) + offset);
798
799     if (memcmp(bytes, ptr_iter, bytes_size) == 0) {
800       return link;
801     }
802   }
803
804   return NULL;
805 }
806
807 /**
808  * Returns the 0-based index of the first element of listbase which contains the specified
809  * null-terminated string at the specified offset, or -1 if not found.
810  */
811 int BLI_findstringindex(const ListBase *listbase, const char *id, const int offset)
812 {
813   Link *link = NULL;
814   const char *id_iter;
815   int i = 0;
816
817   link = listbase->first;
818   while (link) {
819     id_iter = ((const char *)link) + offset;
820
821     if (id[0] == id_iter[0] && STREQ(id, id_iter)) {
822       return i;
823     }
824     i++;
825     link = link->next;
826   }
827
828   return -1;
829 }
830
831 /**
832  * Sets dst to a duplicate of the entire contents of src. dst may be the same as src.
833  */
834 void BLI_duplicatelist(ListBase *dst, const ListBase *src)
835 {
836   struct Link *dst_link, *src_link;
837
838   /* in this order, to ensure it works if dst == src */
839   src_link = src->first;
840   dst->first = dst->last = NULL;
841
842   while (src_link) {
843     dst_link = MEM_dupallocN(src_link);
844     BLI_addtail(dst, dst_link);
845
846     src_link = src_link->next;
847   }
848 }
849
850 void BLI_listbase_reverse(ListBase *lb)
851 {
852   struct Link *curr = lb->first;
853   struct Link *prev = NULL;
854   struct Link *next = NULL;
855   while (curr) {
856     next = curr->next;
857     curr->next = prev;
858     curr->prev = next;
859     prev = curr;
860     curr = next;
861   }
862
863   /* swap first/last */
864   curr = lb->first;
865   lb->first = lb->last;
866   lb->last = curr;
867 }
868
869 /**
870  * \param vlink: Link to make first.
871  */
872 void BLI_listbase_rotate_first(ListBase *lb, void *vlink)
873 {
874   /* make circular */
875   ((Link *)lb->first)->prev = lb->last;
876   ((Link *)lb->last)->next = lb->first;
877
878   lb->first = vlink;
879   lb->last = ((Link *)vlink)->prev;
880
881   ((Link *)lb->first)->prev = NULL;
882   ((Link *)lb->last)->next = NULL;
883 }
884
885 /**
886  * \param vlink: Link to make last.
887  */
888 void BLI_listbase_rotate_last(ListBase *lb, void *vlink)
889 {
890   /* make circular */
891   ((Link *)lb->first)->prev = lb->last;
892   ((Link *)lb->last)->next = lb->first;
893
894   lb->first = ((Link *)vlink)->next;
895   lb->last = vlink;
896
897   ((Link *)lb->first)->prev = NULL;
898   ((Link *)lb->last)->next = NULL;
899 }
900
901 /* create a generic list node containing link to provided data */
902 LinkData *BLI_genericNodeN(void *data)
903 {
904   LinkData *ld;
905
906   if (data == NULL) {
907     return NULL;
908   }
909
910   /* create new link, and make it hold the given data */
911   ld = MEM_callocN(sizeof(LinkData), __func__);
912   ld->data = data;
913
914   return ld;
915 }