abf9dbcd9c59d1652ede7cceda994230d04ade05
[blender-staging.git] / source / blender / blenlib / intern / BLI_args.c
1 /**
2  * A general argument parsing module
3  *
4  * $Id:
5  *
6  * ***** BEGIN GPL LICENSE BLOCK *****
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL LICENSE BLOCK *****
30  */
31
32 #include <ctype.h> /* for tolower */
33
34 #include "MEM_guardedalloc.h"
35
36 #include "BLI_string.h"
37 #include "BLI_args.h"
38 #include "BLI_ghash.h"
39
40 typedef struct bAKey {
41         char *arg;
42         uintptr_t pass; /* cast easier */
43         int case_str; /* case specific or not */
44 } bAKey;
45
46 typedef struct bArgument {
47         bAKey *key;
48         BA_ArgCallback func;
49         void *data;
50 } bArgument;
51
52 struct bArgs {
53         GHash  *items;
54         int     argc;
55         char  **argv;
56         int       *passes;
57 };
58
59 static unsigned int case_strhash(void *ptr) {
60         char *s= ptr;
61         unsigned int i= 0;
62         unsigned char c;
63
64         while ( (c= tolower(*s++)) )
65                 i= i*37 + c;
66
67         return i;
68 }
69
70 static unsigned int     keyhash(void *ptr)
71 {
72         bAKey *k = ptr;
73         return case_strhash(k->arg) ^ BLI_ghashutil_inthash((void*)k->pass);
74 }
75
76 static int keycmp(void *a, void *b)
77 {
78         bAKey *ka = a;
79         bAKey *kb = b;
80         if (ka->pass == kb->pass || ka->pass == -1 || kb->pass == -1) { /* -1 is wildcard for pass */
81                 if (ka->case_str == 1 || kb->case_str == 1)
82                         return BLI_strcasecmp(ka->arg, kb->arg);
83                 else
84                         return strcmp(ka->arg, kb->arg);
85         } else {
86                 return BLI_ghashutil_intcmp((void*)ka->pass, (void*)kb->pass);
87         }
88 }
89
90 static bArgument *lookUp(struct bArgs *ba, char *arg, int pass, int case_str)
91 {
92         bAKey key;
93
94         key.case_str = case_str;
95         key.pass = pass;
96         key.arg = arg;
97
98         return BLI_ghash_lookup(ba->items, &key);
99 }
100
101 bArgs *BLI_argsInit(int argc, char **argv)
102 {
103         bArgs *ba = MEM_callocN(sizeof(bArgs), "bArgs");
104         ba->passes = MEM_callocN(sizeof(int) * argc, "bArgs passes");
105         ba->items = BLI_ghash_new(keyhash, keycmp);
106         ba->argc = argc;
107         ba->argv = argv;
108
109         return ba;
110 }
111
112 static void freeItem(void *val)
113 {
114         MEM_freeN(val);
115 }
116
117 void BLI_argsFree(struct bArgs *ba)
118 {
119         BLI_ghash_free(ba->items, freeItem, freeItem);
120         MEM_freeN(ba->passes);
121         MEM_freeN(ba);
122 }
123
124 void BLI_argsPrint(struct bArgs *ba)
125 {
126         int i;
127         for (i = 0; i < ba->argc; i++) {
128                 printf("argv[%d] = %s\n", i, ba->argv[i]);
129         }
130 }
131
132 char **BLI_argsArgv(struct bArgs *ba)
133 {
134         return ba->argv;
135 }
136
137 static void internalAdd(struct bArgs *ba, char *arg, int pass, int case_str, BA_ArgCallback cb, void *data)
138 {
139         bArgument *a;
140         bAKey *key;
141
142         a = lookUp(ba, arg, pass, case_str);
143
144         if (a) {
145                 printf("WARNING: conflicting argument\n");
146                 printf("\ttrying to add '%s' on pass %i, %scase sensitive\n", arg, pass, case_str == 1? "not ": "");
147                 printf("\tconflict with '%s' on pass %i, %scase sensitive\n\n", a->key->arg, (int)a->key->pass, a->key->case_str == 1? "not ": "");
148         }
149
150         a = MEM_callocN(sizeof(bArgument), "bArgument");
151         key = MEM_callocN(sizeof(bAKey), "bAKey");
152
153         key->arg = arg;
154         key->pass = pass;
155         key->case_str = case_str;
156
157         a->key = key;
158         a->func = cb;
159         a->data = data;
160
161         BLI_ghash_insert(ba->items, key, a);
162 }
163
164 void BLI_argsAdd(struct bArgs *ba, char *arg, int pass, BA_ArgCallback cb, void *data)
165 {
166         internalAdd(ba, arg, pass, 0, cb, data);
167 }
168
169 void BLI_argsAddCase(struct bArgs *ba, char *arg, int pass, BA_ArgCallback cb, void *data)
170 {
171         internalAdd(ba, arg, pass, 1, cb, data);
172 }
173
174
175 void BLI_argsParse(struct bArgs *ba, int pass, BA_ArgCallback default_cb, void *default_data)
176 {
177         int i = 0;
178
179         for( i = 1; i < ba->argc; i++) { /* skip argv[0] */
180                 /* stop on -- */
181                 if (BLI_streq(ba->argv[i], "--"))
182                         break;
183
184                 if (ba->passes[i] == 0) {
185                          /* -1 signal what side of the comparison it is */
186                         bArgument *a = lookUp(ba, ba->argv[i], pass, -1);
187                         BA_ArgCallback func = NULL;
188                         void *data = NULL;
189
190                         if (a) {
191                                 func = a->func;
192                                 data = a->data;
193                         } else {
194                                 func = default_cb;
195                                 data = default_data;
196                         }
197
198                         if (func) {
199                                 int retval = func(ba->argc - i, ba->argv + i, data);
200
201                                 if (retval >= 0) {
202                                         int j;
203
204                                         /* use extra arguments */
205                                         for (j = 0; j <= retval; j++) {
206                                                 ba->passes[i + j] = pass;
207                                         }
208                                         i += retval;
209                                 } else if (retval == -1){
210                                         ba->passes[i] = pass;
211                                         break;
212                                 }
213                         }
214                 }
215         }
216 }