739e60af7a105bf7f08c84e0242f19b448880289
[ccan] / ccan / jmap / _info
1 #include "config.h"
2 #include <stdio.h>
3 #include <string.h>
4
5 /**
6  * jmap - map from indices to values (based on libJudy)
7  *
8  * This provides a convenient wrapper for using JudyL arrays; using
9  * integers or pointers as an index, Judy arrays provide an efficient
10  * map to integers or pointers.
11  *
12  * You define a struct for your particular index and value types using
13  * the JMAP_MEMBERS macro, then use the jmap routines to manipulate
14  * the mapping.
15  *
16  * Note: if you use an integer type for the index or value types and
17  * your compiler doesn't support "typeof", you will get warnings about
18  * mixing pointers and integers.
19  *
20  * Example:
21  * // Silly example of associating data with arguments by pointer and int.
22  * #include <string.h>
23  * #include <stdio.h>
24  * #include <ccan/jmap/jmap.h>
25  * 
26  * struct opt_detail {
27  *      bool is_long;
28  *      size_t length; // == 1 if !is_long.
29  * };
30  * 
31  * // Define map type for int -> argv.
32  * struct arg_map {
33  *      JMAP_MEMBERS(int, char *);
34  * };
35  * // Define map type for argv -> struct opt_detail *.
36  * struct opt_map {
37  *      JMAP_MEMBERS(char *, struct opt_detail *);
38  * };
39  * 
40  * int main(int argc, char *argv[])
41  * {
42  *      int i;
43  *      // This map is equivalent to the argv[] array.  Silly example.
44  *      struct arg_map *arg = jmap_new(struct arg_map);
45  *      struct opt_map *opt = jmap_new(struct opt_map);
46  *      struct opt_detail *d;
47  * 
48  *      // Note: this is not correct for real parsing!
49  *      for (i = 1; i < argc; i++) {
50  *              jmap_add(arg, i, argv[i]);
51  *              if (argv[i][0] != '-')
52  *                      continue;
53  *              d = malloc(sizeof(*d));
54  *              if (argv[i][1] == '-') {
55  *                      // --<stuff>
56  *                      d->is_long = true;
57  *                      d->length = strlen(argv[i]+2);
58  *              } else {
59  *                      // -<opt1>
60  *                      d->is_long = false;
61  *                      d->length = 1;
62  *              }
63  *              jmap_add(opt, argv[i], d);
64  *      }
65  * 
66  *      printf("Found %lu options:\n", jmap_count(opt));
67  *      for (i = jmap_first(arg); i; i = jmap_next(arg,i)) {
68  *              char *a = jmap_get(arg, i);
69  *              d = jmap_get(opt, a);
70  *              printf("  Arg %i ('%s') is a %s of %zu chars\n",
71  *                     i, a,
72  *                     d == NULL ? "normal arg"
73  *                     : d->is_long ? "long opt"
74  *                     : "short opt",
75  *                     d == NULL ? strlen(a) : d->length);
76  *              // We no longer need it, so free it here.
77  *              free(d);
78  *      }
79  *      jmap_free(opt);
80  *      jmap_free(arg);
81  *      return 0;
82  * }
83  * // Given "--help" output contains "Arg 1 ('--help') is a long opt of 4 chars"
84  * // Given "-h" output contains "Arg 1 ('-h') is a short opt of 1 chars"
85  * // Given "foo" output contains "Arg 1 ('foo') is a normal arg of 3 chars"
86  *
87  * License: LGPL (v2.1 or any later version)
88  * Author: Rusty Russell <rusty@rustcorp.com.au>
89  */
90 int main(int argc, char *argv[])
91 {
92         if (argc != 2)
93                 return 1;
94
95         if (strcmp(argv[1], "depends") == 0) {
96                 printf("ccan/build_assert\n");
97                 printf("ccan/compiler\n");
98                 printf("ccan/tcon\n");
99                 printf("Judy\n");
100                 return 0;
101         }
102
103         if (strcmp(argv[1], "libs") == 0) {
104                 printf("Judy\n");
105                 return 0;
106         }
107
108         return 1;
109 }