Mercurial > hg > dav / file comparison

comparison: dav/optparser.c

dav/optparser.c

changeset 747
efbd59642577
parent 721
c401f4af44b1
equal deleted inserted replaced
746:a569148841ff 747:efbd59642577
31 #include <string.h> 31 #include <string.h>
32 32
33 #include "optparser.h" 33 #include "optparser.h"
34 #include "sopt.h" 34 #include "sopt.h"
35 35
36 #include <cx/hash_map.h>
37
38
36 void cmd_args_free(CmdArgs *args) { 39 void cmd_args_free(CmdArgs *args) {
37 if(args) { 40 if(args) {
38 ucx_map_free(args->options); 41 cxMapDestroy(args->options);
39 if(args->argv) { 42 if(args->argv) {
40 free(args->argv); 43 free(args->argv);
41 } 44 }
42 free(args); 45 free(args);
43 } 46 }
44 } 47 }
45 48
49 static void cmd_map_put(CxMap *map, const char *key, const void *value) {
50 cxMapPut(map, key, (void*)value);
51 }
52
46 CmdArgs* cmd_parse_args(int argc, char **argv) { 53 CmdArgs* cmd_parse_args(int argc, char **argv) {
47 CmdArgs *a = malloc(sizeof(CmdArgs)); 54 CmdArgs *a = malloc(sizeof(CmdArgs));
48 a->options = ucx_map_new(16); 55 a->options = cxHashMapCreate(cxDefaultAllocator, CX_STORE_POINTERS, 16);
49 a->argv = argc > 0 ? calloc(argc, sizeof(char*)) : NULL; 56 a->argv = argc > 0 ? calloc(argc, sizeof(char*)) : NULL;
50 a->argc = 0; 57 a->argc = 0;
51 58
52 const char *NOARG = ""; 59 const char *NOARG = "";
53 60
69 return NULL; 76 return NULL;
70 } 77 }
71 for(int c=1;c<len;c++) { 78 for(int c=1;c<len;c++) {
72 // argument is in the same arg 79 // argument is in the same arg
73 if(option) { 80 if(option) {
74 ucx_map_cstr_put(a->options, option, &arg[c]); 81 cxMapPut(a->options, cx_hash_key_str(option), &arg[c]);
75 option = NULL; 82 option = NULL;
76 break; 83 break;
77 } 84 }
78 85
79 switch(arg[c]) { 86 switch(arg[c]) {
81 fprintf(stderr, "Unknown option -%c\n\n", arg[c]); 88 fprintf(stderr, "Unknown option -%c\n\n", arg[c]);
82 cmd_args_free(a); 89 cmd_args_free(a);
83 return NULL; 90 return NULL;
84 } 91 }
85 case 'v': { 92 case 'v': {
86 ucx_map_cstr_put(a->options, "verbose", NOARG); 93 cmd_map_put(a->options, "verbose", NOARG);
87 break; 94 break;
88 } 95 }
89 case 'k': { 96 case 'k': {
90 option = "key"; 97 option = "key";
91 optchar = 'k'; 98 optchar = 'k';
92 break; 99 break;
93 } 100 }
94 case 'p': { 101 case 'p': {
95 ucx_map_cstr_put(a->options, "plain", NOARG); 102 cmd_map_put(a->options, "plain", NOARG);
96 break; 103 break;
97 } 104 }
98 case 'c': { 105 case 'c': {
99 ucx_map_cstr_put(a->options, "crypt", NOARG); 106 cmd_map_put(a->options, "crypt", NOARG);
100 break; 107 break;
101 } 108 }
102 case 'a': { 109 case 'a': {
103 ucx_map_cstr_put(a->options, "all", NOARG); 110 cmd_map_put(a->options, "all", NOARG);
104 break; 111 break;
105 } 112 }
106 case 'l': { 113 case 'l': {
107 ucx_map_cstr_put(a->options, "list", NOARG); 114 cmd_map_put(a->options, "list", NOARG);
108 break; 115 break;
109 } 116 }
110 case 'd': { 117 case 'd': {
111 ucx_map_cstr_put(a->options, "date", NOARG); 118 cmd_map_put(a->options, "date", NOARG);
112 break; 119 break;
113 } 120 }
114 case 't': { 121 case 't': {
115 ucx_map_cstr_put(a->options, "type", NOARG); 122 cmd_map_put(a->options, "type", NOARG);
116 break; 123 break;
117 } 124 }
118 case 'R': { 125 case 'R': {
119 ucx_map_cstr_put(a->options, "recursive", NOARG); 126 cmd_map_put(a->options, "recursive", NOARG);
120 break; 127 break;
121 } 128 }
122 case 'O': { 129 case 'O': {
123 ucx_map_cstr_put(a->options, "override", NOARG); 130 cmd_map_put(a->options, "override", NOARG);
124 break; 131 break;
125 } 132 }
126 case 'i': { 133 case 'i': {
127 ucx_map_cstr_put(a->options, "insecure", NOARG); 134 cmd_map_put(a->options, "insecure", NOARG);
128 break; 135 break;
129 } 136 }
130 case 'N': { 137 case 'N': {
131 ucx_map_cstr_put(a->options, "noinput", NOARG); 138 cmd_map_put(a->options, "noinput", NOARG);
132 break; 139 break;
133 } 140 }
134 case 'e': { 141 case 'e': {
135 ucx_map_cstr_put(a->options, "extended", NOARG); 142 cmd_map_put(a->options, "extended", NOARG);
136 break; 143 break;
137 } 144 }
138 case 'x': { 145 case 'x': {
139 ucx_map_cstr_put(a->options, "xml", NOARG); 146 cmd_map_put(a->options, "xml", NOARG);
140 break; 147 break;
141 } 148 }
142 case 'F': { 149 case 'F': {
143 option = "finfo"; 150 option = "finfo";
144 optchar = 'F'; 151 optchar = 'F';
145 break; 152 break;
146 } 153 }
147 case 'S': { 154 case 'S': {
148 // undocumented hidden feature 155 // undocumented hidden feature
149 ucx_map_cstr_put(a->options, "structure", NOARG); 156 cmd_map_put(a->options, "structure", NOARG);
150 break; 157 break;
151 } 158 }
152 case 'K': { 159 case 'K': {
153 ucx_map_cstr_put(a->options, "keep", NOARG); 160 cmd_map_put(a->options, "keep", NOARG);
154 break; 161 break;
155 } 162 }
156 case 'o': { 163 case 'o': {
157 option = "output"; 164 option = "output";
158 optchar = 'o'; 165 optchar = 'o';
191 break; 198 break;
192 } 199 }
193 } 200 }
194 } 201 }
195 } else if(option) { 202 } else if(option) {
196 ucx_map_cstr_put(a->options, option, arg); 203 cmd_map_put(a->options, option, arg);
197 option = NULL; 204 option = NULL;
198 } else { 205 } else {
199 a->argv[a->argc++] = arg; 206 a->argv[a->argc++] = arg;
200 } 207 }
201 } 208 }
207 } 214 }
208 215
209 return a; 216 return a;
210 } 217 }
211 218
212 char* cmd_getoption(CmdArgs *arg, char *name) { 219 char* cmd_getoption(CmdArgs *arg, const char *name) {
213 return ucx_map_cstr_get(arg->options, name); 220 return cxMapGet(arg->options, cx_hash_key_str(name));
214 } 221 }

Mercurial Repository: dav

mercurial