avoid dead code in i_tt_glyph_names()
[imager.git] / tags.c
1 /*
2 =head1 NAME
3
4 tags.c - functions for manipulating an images tags list
5
6 =head1 SYNOPSIS
7
8   i_img_tags tags;
9   i_tags_new(&tags);
10   i_tags_destroy(&tags);
11   i_tags_addn(&tags, "name", code, idata);
12   i_tags_add(&tags, "name", code, data, data_size, idata);
13   if (i_tags_find(&tags, name, start, &entry)) { found }
14   if (i_tags_findn(&tags, code, start, &entry)) { found }
15   i_tags_delete(&tags, index);
16   count = i_tags_delbyname(tags, name);
17   count = i_tags_delbycode(tags, code);
18   if (i_tags_get_float(&tags, name, code, &float_value)) { found }
19   i_tags_set_float(&tags, name, code, value);
20   i_tags_set_float2(&tags, name, code, value, sig_digits);
21   i_tags_get_int(&tags, name, code, &int_value);
22
23 =head1 DESCRIPTION
24
25 Provides functions which give write access to the tags list of an image.
26
27 For read access directly access the fields (do not write any fields
28 directly).
29
30 A tag is represented by an i_img_tag structure:
31
32   typedef enum {
33     itt_double,
34     iit_text
35   } i_tag_type;
36
37   typedef struct {
38     char *name; // name of a given tag, might be NULL 
39     int code; // number of a given tag, -1 if it has no meaning 
40     char *data; // value of a given tag if it's not an int, may be NULL 
41     int size; // size of the data 
42     int idata; // value of a given tag if data is NULL 
43   } i_img_tag;
44
45
46 =over
47
48 =cut
49 */
50
51 #include "imager.h"
52 #include <string.h>
53 #include <stdlib.h>
54 #include <errno.h>
55 #include <limits.h>
56
57 /* useful for debugging */
58 void i_tags_print(i_img_tags *tags);
59
60 /*
61 =item i_tags_new(i_img_tags *tags)
62
63 =category Tags
64
65 Initialize a tags structure.  Should not be used if the tags structure
66 has been previously used.
67
68 This should be called tags member of an i_img object on creation (in
69 i_img_*_new() functions).
70
71 To destroy the contents use i_tags_destroy()
72
73 =cut
74 */
75
76 void i_tags_new(i_img_tags *tags) {
77   tags->count = tags->alloc = 0;
78   tags->tags = NULL;
79 }
80
81 /*
82 =item i_tags_addn(i_img_tags *tags, char *name, int code, int idata)
83
84 Adds a tag that has an integer value.  A simple wrapper around i_tags_add().
85
86 Use i_tags_setn() instead, this function may be removed in the future.
87
88 Returns non-zero on success.
89
90 =cut
91 */
92
93 int i_tags_addn(i_img_tags *tags, char const *name, int code, int idata) {
94   return i_tags_add(tags, name, code, NULL, 0, idata);
95 }
96
97 /*
98 =item i_tags_add(i_img_tags *tags, char *name, int code, char *data, int size, i_tag_type type, int idata)
99
100 Adds a tag to the tags list.
101
102 Use i_tags_set() instead, this function may be removed in the future.
103
104 Returns non-zero on success.
105
106 =cut
107 */
108
109 int i_tags_add(i_img_tags *tags, char const *name, int code, char const *data, 
110                int size, int idata) {
111   i_img_tag work = {0};
112   /*printf("i_tags_add(tags %p [count %d], name %s, code %d, data %p, size %d, idata %d)\n",
113     tags, tags->count, name, code, data, size, idata);*/
114   if (tags->tags == NULL) {
115     int alloc = 10;
116     tags->tags = mymalloc(sizeof(i_img_tag) * alloc);
117     if (!tags->tags)
118       return 0;
119     tags->alloc = alloc;
120   }
121   else if (tags->count == tags->alloc) {
122     int newalloc = tags->alloc + 10;
123     void *newtags = myrealloc(tags->tags, sizeof(i_img_tag) * newalloc);
124     if (!newtags) {
125       return 0;
126     }
127     tags->tags = newtags;
128     tags->alloc = newalloc;
129   }
130   if (name) {
131     work.name = mymalloc(strlen(name)+1);
132     if (!work.name)
133       return 0;
134     strcpy(work.name, name);
135   }
136   if (data) {
137     if (size == -1)
138       size = strlen(data);
139     work.data = mymalloc(size+1);
140     if (!work.data) {
141       if (work.name) myfree(work.name);
142       return 0;
143     }
144     memcpy(work.data, data, size);
145     work.data[size] = '\0'; /* convenience */
146     work.size = size;
147   }
148   work.code = code;
149   work.idata = idata;
150   tags->tags[tags->count++] = work;
151
152   /*i_tags_print(tags);*/
153
154   return 1;
155 }
156
157 /*
158 =item i_tags_destroy(tags)
159
160 =category Tags
161
162 Destroys the given tags structure.  Called by i_img_destroy().
163
164 =cut
165 */
166
167 void i_tags_destroy(i_img_tags *tags) {
168   if (tags->tags) {
169     int i;
170     for (i = 0; i < tags->count; ++i) {
171       if (tags->tags[i].name)
172         myfree(tags->tags[i].name);
173       if (tags->tags[i].data)
174         myfree(tags->tags[i].data);
175     }
176     myfree(tags->tags);
177   }
178 }
179
180 /*
181 =item i_tags_find(tags, name, start, &entry)
182
183 =category Tags
184
185 Searches for a tag of the given I<name> starting from index I<start>.
186
187 On success returns true and sets *I<entry>.
188
189 On failure returns false.
190
191 =cut
192 */
193
194 int i_tags_find(i_img_tags *tags, char const *name, int start, int *entry) {
195   if (tags->tags) {
196     while (start < tags->count) {
197       if (tags->tags[start].name && strcmp(name, tags->tags[start].name) == 0) {
198         *entry = start;
199         return 1;
200       }
201       ++start;
202     }
203   }
204   return 0;
205 }
206
207 /*
208 =item i_tags_findn(tags, code, start, &entry)
209
210 =category Tags
211
212 Searches for a tag of the given I<code> starting from index I<start>.
213
214 On success returns true and sets *I<entry>.
215
216 On failure returns false.
217
218 =cut
219 */
220
221 int i_tags_findn(i_img_tags *tags, int code, int start, int *entry) {
222   if (tags->tags) {
223     while (start < tags->count) {
224       if (tags->tags[start].code == code) {
225         *entry = start;
226         return 1;
227       }
228       ++start;
229     }
230   }
231   return 0;
232 }
233
234 /*
235 =item i_tags_delete(tags, index)
236
237 =category Tags
238
239 Delete a tag by index.
240
241 Returns true on success.
242
243 =cut
244 */
245 int i_tags_delete(i_img_tags *tags, int entry) {
246   /*printf("i_tags_delete(tags %p [count %d], entry %d)\n",
247     tags, tags->count, entry);*/
248   if (tags->tags && entry >= 0 && entry < tags->count) {
249     i_img_tag old = tags->tags[entry];
250     memmove(tags->tags+entry, tags->tags+entry+1,
251             (tags->count-entry-1) * sizeof(i_img_tag));
252     if (old.name)
253       myfree(old.name);
254     if (old.data)
255       myfree(old.data);
256     --tags->count;
257
258     return 1;
259   }
260   return 0;
261 }
262
263 /*
264 =item i_tags_delbyname(tags, name)
265
266 =category Tags
267
268 Delete any tags with the given name.
269
270 Returns the number of tags deleted.
271
272 =cut
273 */
274
275 int i_tags_delbyname(i_img_tags *tags, char const *name) {
276   int count = 0;
277   int i;
278   /*printf("i_tags_delbyname(tags %p [count %d], name %s)\n",
279     tags, tags->count, name);*/
280   if (tags->tags) {
281     for (i = tags->count-1; i >= 0; --i) {
282       if (tags->tags[i].name && strcmp(name, tags->tags[i].name) == 0) {
283         ++count;
284         i_tags_delete(tags, i);
285       }
286     }
287   }
288   /*i_tags_print(tags);*/
289
290   return count;
291 }
292
293 /*
294 =item i_tags_delbycode(tags, code)
295
296 =category Tags
297
298 Delete any tags with the given code.
299
300 Returns the number of tags deleted.
301
302 =cut
303 */
304
305 int i_tags_delbycode(i_img_tags *tags, int code) {
306   int count = 0;
307   int i;
308   if (tags->tags) {
309     for (i = tags->count-1; i >= 0; --i) {
310       if (tags->tags[i].code == code) {
311         ++count;
312         i_tags_delete(tags, i);
313       }
314     }
315   }
316   return count;
317 }
318
319 /*
320 =item i_tags_get_float(tags, name, code, value)
321
322 =category Tags
323
324 Retrieves a tag as a floating point value.  
325
326 If the tag has a string value then that is parsed as a floating point
327 number, otherwise the integer value of the tag is used.
328
329 On success sets *I<value> and returns true.
330
331 On failure returns false.
332
333 =cut
334 */
335
336 int i_tags_get_float(i_img_tags *tags, char const *name, int code, 
337                      double *value) {
338   int index;
339   i_img_tag *entry;
340
341   if (name) {
342     if (!i_tags_find(tags, name, 0, &index))
343       return 0;
344   }
345   else {
346     if (!i_tags_findn(tags, code, 0, &index))
347       return 0;
348   }
349   entry = tags->tags+index;
350   if (entry->data)
351     *value = atof(entry->data);
352   else
353     *value = entry->idata;
354
355   return 1;
356 }
357
358 /*
359 =item i_tags_set_float(tags, name, code, value)
360
361 =category Tags
362
363 Equivalent to i_tags_set_float2(tags, name, code, value, 30).
364
365 =cut
366 */
367
368 int i_tags_set_float(i_img_tags *tags, char const *name, int code, 
369                      double value) {
370   return i_tags_set_float2(tags, name, code, value, 30);
371 }
372
373 /*
374 =item i_tags_set_float2(tags, name, code, value, places)
375
376 =category Tags
377
378 Sets the tag with the given name and code to the given floating point
379 value.
380
381 Since tags are strings or ints, we convert the value to a string before
382 storage at the precision specified by C<places>.
383
384 =cut
385 */
386
387 int i_tags_set_float2(i_img_tags *tags, char const *name, int code, 
388                       double value, int places) {
389   char temp[40];
390
391   if (places < 0) 
392     places = 30;
393   else if (places > 30) 
394     places = 30;
395
396   sprintf(temp, "%.*g", places, value);
397   if (name)
398     i_tags_delbyname(tags, name);
399   else
400     i_tags_delbycode(tags, code);
401
402   return i_tags_add(tags, name, code, temp, strlen(temp), 0);
403 }
404
405 /*
406 =item i_tags_get_int(tags, name, code, &value)
407
408 =category Tags
409
410 Retrieve a tag specified by name or code as an integer.
411
412 On success sets the int *I<value> to the integer and returns true.
413
414 On failure returns false.
415
416 =cut
417 */
418
419 int i_tags_get_int(i_img_tags *tags, char const *name, int code, int *value) {
420   int index;
421   i_img_tag *entry;
422
423   if (name) {
424     if (!i_tags_find(tags, name, 0, &index))
425       return 0;
426   }
427   else {
428     if (!i_tags_findn(tags, code, 0, &index))
429       return 0;
430   }
431   entry = tags->tags+index;
432   if (entry->data)
433     *value = atoi(entry->data);
434   else
435     *value = entry->idata;
436
437   return 1;
438 }
439
440 static int parse_long(char *data, char **end, long *out) {
441   long result;
442   int savederr = errno;
443   char *myend;
444
445   errno = 0;
446   result = strtol(data, &myend, 10);
447   if (((result == LONG_MIN || result == LONG_MAX) && errno == ERANGE)
448       || myend == data) {
449     errno = savederr;
450     return 0;
451   }
452
453   errno = savederr;
454   *out = result;
455   *end = myend;
456
457   return 1;
458 }
459
460 /* parse a comma-separated list of integers
461    returns when it has maxcount numbers, finds a non-comma after a number
462    or can't parse a number
463    if it can't parse a number after a comma, that's considered an error
464 */
465 static int parse_long_list(char *data, char **end, int maxcount, long *out) {
466   int i;
467
468   i = 0;
469   while (i < maxcount-1) {
470     if (!parse_long(data, &data, out))
471       return 0;
472     out++;
473     i++;
474     if (*data != ',')
475       return i;
476     ++data;
477   }
478   if (!parse_long(data, &data, out))
479     return 0;
480   ++i;
481   *end = data;
482   return i;
483 }
484
485 /* parse "color(red,green,blue,alpha)" */
486 static int parse_color(char *data, char **end, i_color *value) {
487   long n[4];
488   int count, i;
489   
490   if (memcmp(data, "color(", 6))
491     return 0; /* not a color */
492   data += 6;
493   count = parse_long_list(data, &data, 4, n);
494   if (count < 3)
495     return 0;
496   for (i = 0; i < count; ++i)
497     value->channel[i] = n[i];
498   if (count < 4)
499     value->channel[3] = 255;
500
501   return 1;
502 }
503
504 /*
505 =item i_tags_get_color(tags, name, code, &value)
506
507 =category Tags
508
509 Retrieve a tag specified by name or code as color.
510
511 On success sets the i_color *I<value> to the color and returns true.
512
513 On failure returns false.
514
515 =cut
516 */
517
518 int i_tags_get_color(i_img_tags *tags, char const *name, int code, 
519                      i_color *value) {
520   int index;
521   i_img_tag *entry;
522   char *end;
523
524   if (name) {
525     if (!i_tags_find(tags, name, 0, &index))
526       return 0;
527   }
528   else {
529     if (!i_tags_findn(tags, code, 0, &index))
530       return 0;
531   }
532   entry = tags->tags+index;
533   if (!entry->data) 
534     return 0;
535
536   if (!parse_color(entry->data, &end, value))
537     return 0;
538   
539   /* for now we're sloppy about the end */
540
541   return 1;
542 }
543
544 /*
545 =item i_tags_set_color(tags, name, code, &value)
546
547 =category Tags
548
549 Stores the given color as a tag with the given name and code.
550
551 =cut
552 */
553
554 int i_tags_set_color(i_img_tags *tags, char const *name, int code, 
555                      i_color const *value) {
556   char temp[80];
557
558   sprintf(temp, "color(%d,%d,%d,%d)", value->channel[0], value->channel[1],
559           value->channel[2], value->channel[3]);
560   if (name)
561     i_tags_delbyname(tags, name);
562   else
563     i_tags_delbycode(tags, code);
564
565   return i_tags_add(tags, name, code, temp, strlen(temp), 0);
566 }
567
568 /*
569 =item i_tags_get_string(tags, name, code, value, value_size)
570
571 =category Tags
572
573 Retrieves a tag by name or code as a string.
574
575 On success copies the string to value for a max of value_size and
576 returns true.
577
578 On failure returns false.
579
580 value_size must be at least large enough for a string representation
581 of an integer.
582
583 The copied value is always C<NUL> terminated.
584
585 =cut
586 */
587
588 int i_tags_get_string(i_img_tags *tags, char const *name, int code, 
589                       char *value, size_t value_size) {
590   int index;
591   i_img_tag *entry;
592
593   if (name) {
594     if (!i_tags_find(tags, name, 0, &index))
595       return 0;
596   }
597   else {
598     if (!i_tags_findn(tags, code, 0, &index))
599       return 0;
600   }
601   entry = tags->tags+index;
602   if (entry->data) {
603     size_t cpsize = value_size < entry->size ? value_size : entry->size;
604     memcpy(value, entry->data, cpsize);
605     if (cpsize == value_size)
606       --cpsize;
607     value[cpsize] = '\0';
608   }
609   else {
610     sprintf(value, "%d", entry->idata);
611   }
612
613   return 1;
614 }
615
616 /*
617 =item i_tags_set(tags, name, data, size)
618 =synopsis i_tags_set(&img->tags, "i_comment", -1);
619 =category Tags
620
621 Sets the given tag to the string I<data>
622
623 If size is -1 then the strlen(I<data>) bytes are stored.
624
625 Even on failure, if an existing tag I<name> exists, it will be
626 removed.
627
628 =cut
629 */
630
631 int
632 i_tags_set(i_img_tags *tags, char const *name, char const *data, int size) {
633   i_tags_delbyname(tags, name);
634
635   return i_tags_add(tags, name, 0, data, size, 0);
636 }
637
638 /*
639 =item i_tags_setn(C<tags>, C<name>, C<idata>)
640 =synopsis i_tags_setn(&img->tags, "i_xres", 204);
641 =synopsis i_tags_setn(&img->tags, "i_yres", 196);
642 =category Tags
643
644 Sets the given tag to the integer C<idata>
645
646 Even on failure, if an existing tag C<name> exists, it will be
647 removed.
648
649 =cut
650 */
651
652 int
653 i_tags_setn(i_img_tags *tags, char const *name, int idata) {
654   i_tags_delbyname(tags, name);
655
656   return i_tags_addn(tags, name, 0, idata);
657 }
658
659 void i_tags_print(i_img_tags *tags) {
660   int i;
661   printf("Alloc %d\n", tags->alloc);
662   printf("Count %d\n", tags->count);
663   for (i = 0; i < tags->count; ++i) {
664     i_img_tag *tag = tags->tags + i;
665     printf("Tag %d\n", i);
666     if (tag->name)
667       printf(" Name : %s (%p)\n", tag->name, tag->name);
668     printf(" Code : %d\n", tag->code);
669     if (tag->data) {
670       int pos;
671       printf(" Data : %d (%p) => '", tag->size, tag->data);
672       for (pos = 0; pos < tag->size; ++pos) {
673         if (tag->data[pos] == '\\' || tag->data[pos] == '\'') {
674           putchar('\\');
675           putchar(tag->data[pos]);
676         }
677         else if (tag->data[pos] < ' ' || tag->data[pos] >= '\x7E')
678           printf("\\x%02X", tag->data[pos]);
679         else
680           putchar(tag->data[pos]);
681       }
682       printf("'\n");
683       printf(" Idata: %d\n", tag->idata);
684     }
685   }
686 }
687
688 /*
689 =back
690
691 =head1 AUTHOR
692
693 Tony Cook <tony@develop-help.com>
694
695 =head1 SEE ALSO
696
697 Imager(3)
698
699 =cut
700 */