param.c 9.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388
  1. /*
  2. * param.c
  3. *
  4. * This file provides the implementation of the "param" class
  5. */
  6. #include "private.h"
  7. #include "lub/string.h"
  8. #include "clish/types.h"
  9. #include <assert.h>
  10. #include <stdlib.h>
  11. #include <stdio.h>
  12. #include <string.h>
  13. /*---------------------------------------------------------
  14. * PRIVATE METHODS
  15. *--------------------------------------------------------- */
  16. static void clish_param_init(clish_param_t *this, const char *name,
  17. const char *text, clish_ptype_t *ptype)
  18. {
  19. /* initialise the help part */
  20. this->name = lub_string_dup(name);
  21. this->text = lub_string_dup(text);
  22. this->ptype = ptype;
  23. /* set up defaults */
  24. this->defval = NULL;
  25. this->mode = CLISH_PARAM_COMMON;
  26. this->optional = BOOL_FALSE;
  27. this->order = BOOL_FALSE;
  28. this->value = NULL;
  29. this->hidden = BOOL_FALSE;
  30. this->test = NULL;
  31. this->completion = NULL;
  32. this->paramv = clish_paramv_new();
  33. }
  34. /*--------------------------------------------------------- */
  35. static void clish_param_fini(clish_param_t * this)
  36. {
  37. /* deallocate the memory for this instance */
  38. lub_string_free(this->defval);
  39. lub_string_free(this->name);
  40. lub_string_free(this->text);
  41. lub_string_free(this->value);
  42. lub_string_free(this->test);
  43. lub_string_free(this->completion);
  44. clish_paramv_delete(this->paramv);
  45. }
  46. /*---------------------------------------------------------
  47. * PUBLIC META FUNCTIONS
  48. *--------------------------------------------------------- */
  49. clish_param_t *clish_param_new(const char *name, const char *text,
  50. clish_ptype_t *ptype)
  51. {
  52. clish_param_t *this = malloc(sizeof(clish_param_t));
  53. if (this)
  54. clish_param_init(this, name, text, ptype);
  55. return this;
  56. }
  57. /*---------------------------------------------------------
  58. * PUBLIC METHODS
  59. *--------------------------------------------------------- */
  60. void clish_param_delete(clish_param_t * this)
  61. {
  62. clish_param_fini(this);
  63. free(this);
  64. }
  65. /*--------------------------------------------------------- */
  66. void clish_param_insert_param(clish_param_t * this, clish_param_t * param)
  67. {
  68. return clish_paramv_insert(this->paramv, param);
  69. }
  70. /*---------------------------------------------------------
  71. * PUBLIC ATTRIBUTES
  72. *--------------------------------------------------------- */
  73. const char *clish_param__get_name(const clish_param_t * this)
  74. {
  75. if (!this)
  76. return NULL;
  77. return this->name;
  78. }
  79. /*--------------------------------------------------------- */
  80. const char *clish_param__get_text(const clish_param_t * this)
  81. {
  82. return this->text;
  83. }
  84. /*--------------------------------------------------------- */
  85. const char *clish_param__get_range(const clish_param_t * this)
  86. {
  87. return clish_ptype__get_range(this->ptype);
  88. }
  89. /*--------------------------------------------------------- */
  90. clish_ptype_t *clish_param__get_ptype(const clish_param_t * this)
  91. {
  92. return this->ptype;
  93. }
  94. /*--------------------------------------------------------- */
  95. void clish_param__set_default(clish_param_t * this, const char *defval)
  96. {
  97. assert(!this->defval);
  98. this->defval = lub_string_dup(defval);
  99. }
  100. /*--------------------------------------------------------- */
  101. const char *clish_param__get_default(const clish_param_t * this)
  102. {
  103. return this->defval;
  104. }
  105. /*--------------------------------------------------------- */
  106. void clish_param__set_mode(clish_param_t * this, clish_param_mode_e mode)
  107. {
  108. assert(this);
  109. this->mode = mode;
  110. }
  111. /*--------------------------------------------------------- */
  112. clish_param_mode_e clish_param__get_mode(const clish_param_t * this)
  113. {
  114. return this->mode;
  115. }
  116. /*--------------------------------------------------------- */
  117. char *clish_param_validate(const clish_param_t * this, const char *text)
  118. {
  119. if (CLISH_PARAM_SUBCOMMAND == clish_param__get_mode(this)) {
  120. if (lub_string_nocasecmp(clish_param__get_value(this), text))
  121. return NULL;
  122. }
  123. return clish_ptype_translate(this->ptype, text);
  124. }
  125. /*--------------------------------------------------------- */
  126. void clish_param_help(const clish_param_t * this, clish_help_t *help)
  127. {
  128. const char *range = clish_ptype__get_range(this->ptype);
  129. const char *name;
  130. char *str = NULL;
  131. if (CLISH_PARAM_SWITCH == clish_param__get_mode(this)) {
  132. unsigned rec_paramc = clish_param__get_param_count(this);
  133. clish_param_t *cparam;
  134. unsigned i;
  135. for (i = 0; i < rec_paramc; i++) {
  136. cparam = clish_param__get_param(this, i);
  137. if (!cparam)
  138. break;
  139. clish_param_help(cparam, help);
  140. }
  141. return;
  142. }
  143. if (CLISH_PARAM_SUBCOMMAND == clish_param__get_mode(this))
  144. name = clish_param__get_value(this);
  145. else
  146. if (!(name = clish_ptype__get_text(this->ptype)))
  147. name = clish_ptype__get_name(this->ptype);
  148. lub_string_cat(&str, this->text);
  149. if (range) {
  150. lub_string_cat(&str, " (");
  151. lub_string_cat(&str, range);
  152. lub_string_cat(&str, ")");
  153. }
  154. lub_argv_add(help->name, name);
  155. lub_argv_add(help->help, str);
  156. lub_string_free(str);
  157. lub_argv_add(help->detail, NULL);
  158. }
  159. /*--------------------------------------------------------- */
  160. void clish_param_help_arrow(const clish_param_t * this, size_t offset)
  161. {
  162. fprintf(stderr, "%*c\n", (int)offset, '^');
  163. }
  164. /*--------------------------------------------------------- */
  165. clish_param_t *clish_param__get_param(const clish_param_t * this,
  166. unsigned index)
  167. {
  168. return clish_paramv__get_param(this->paramv, index);
  169. }
  170. /*--------------------------------------------------------- */
  171. clish_paramv_t *clish_param__get_paramv(clish_param_t * this)
  172. {
  173. return this->paramv;
  174. }
  175. /*--------------------------------------------------------- */
  176. unsigned int clish_param__get_param_count(const clish_param_t * this)
  177. {
  178. return clish_paramv__get_count(this->paramv);
  179. }
  180. /*--------------------------------------------------------- */
  181. void clish_param__set_optional(clish_param_t * this, bool_t optional)
  182. {
  183. this->optional = optional;
  184. }
  185. /*--------------------------------------------------------- */
  186. bool_t clish_param__get_optional(const clish_param_t * this)
  187. {
  188. return this->optional;
  189. }
  190. /*--------------------------------------------------------- */
  191. void clish_param__set_order(clish_param_t * this, bool_t order)
  192. {
  193. this->order = order;
  194. }
  195. /*--------------------------------------------------------- */
  196. bool_t clish_param__get_order(const clish_param_t * this)
  197. {
  198. return this->order;
  199. }
  200. /*--------------------------------------------------------- */
  201. /* paramv methods */
  202. /*--------------------------------------------------------- */
  203. static void clish_paramv_init(clish_paramv_t * this)
  204. {
  205. this->paramc = 0;
  206. this->paramv = NULL;
  207. }
  208. /*--------------------------------------------------------- */
  209. static void clish_paramv_fini(clish_paramv_t * this)
  210. {
  211. unsigned i;
  212. /* finalize each of the parameter instances */
  213. for (i = 0; i < this->paramc; i++) {
  214. clish_param_delete(this->paramv[i]);
  215. }
  216. /* free the parameter vector */
  217. free(this->paramv);
  218. this->paramc = 0;
  219. }
  220. /*--------------------------------------------------------- */
  221. clish_paramv_t *clish_paramv_new(void)
  222. {
  223. clish_paramv_t *this = malloc(sizeof(clish_paramv_t));
  224. if (this)
  225. clish_paramv_init(this);
  226. return this;
  227. }
  228. /*--------------------------------------------------------- */
  229. void clish_paramv_delete(clish_paramv_t * this)
  230. {
  231. clish_paramv_fini(this);
  232. free(this);
  233. }
  234. /*--------------------------------------------------------- */
  235. void clish_paramv_insert(clish_paramv_t * this, clish_param_t * param)
  236. {
  237. size_t new_size = ((this->paramc + 1) * sizeof(clish_param_t *));
  238. clish_param_t **tmp;
  239. /* resize the parameter vector */
  240. tmp = realloc(this->paramv, new_size);
  241. if (tmp) {
  242. this->paramv = tmp;
  243. /* insert reference to the parameter */
  244. this->paramv[this->paramc++] = param;
  245. }
  246. }
  247. /*--------------------------------------------------------- */
  248. clish_param_t *clish_paramv__get_param(const clish_paramv_t * this,
  249. unsigned index)
  250. {
  251. clish_param_t *result = NULL;
  252. if (index < this->paramc)
  253. result = this->paramv[index];
  254. return result;
  255. }
  256. /*--------------------------------------------------------- */
  257. clish_param_t *clish_paramv_find_param(const clish_paramv_t * this,
  258. const char *name)
  259. {
  260. clish_param_t *res = NULL;
  261. unsigned int i;
  262. for (i = 0; i < this->paramc; i++) {
  263. if (!strcmp(clish_param__get_name(this->paramv[i]), name))
  264. return this->paramv[i];
  265. if ((res = clish_paramv_find_param(
  266. clish_param__get_paramv(this->paramv[i]), name)))
  267. return res;
  268. }
  269. return res;
  270. }
  271. /*--------------------------------------------------------- */
  272. const char *clish_paramv_find_default(const clish_paramv_t * this,
  273. const char *name)
  274. {
  275. clish_param_t *res = clish_paramv_find_param(this, name);
  276. if (res)
  277. return clish_param__get_default(res);
  278. return NULL;
  279. }
  280. /*--------------------------------------------------------- */
  281. unsigned int clish_paramv__get_count(const clish_paramv_t * this)
  282. {
  283. return this->paramc;
  284. }
  285. /*--------------------------------------------------------- */
  286. void clish_param__set_value(clish_param_t * this, const char * value)
  287. {
  288. assert(!this->value);
  289. this->value = lub_string_dup(value);
  290. }
  291. /*--------------------------------------------------------- */
  292. char *clish_param__get_value(const clish_param_t * this)
  293. {
  294. if (this->value)
  295. return this->value;
  296. return this->name;
  297. }
  298. /*--------------------------------------------------------- */
  299. void clish_param__set_hidden(clish_param_t * this, bool_t hidden)
  300. {
  301. this->hidden = hidden;
  302. }
  303. /*--------------------------------------------------------- */
  304. bool_t clish_param__get_hidden(const clish_param_t * this)
  305. {
  306. return this->hidden;
  307. }
  308. /*--------------------------------------------------------- */
  309. void clish_param__set_test(clish_param_t * this, const char *test)
  310. {
  311. assert(!this->test);
  312. this->test = lub_string_dup(test);
  313. }
  314. /*--------------------------------------------------------- */
  315. char *clish_param__get_test(const clish_param_t *this)
  316. {
  317. return this->test;
  318. }
  319. /*--------------------------------------------------------- */
  320. void clish_param__set_completion(clish_param_t *this, const char *completion)
  321. {
  322. assert(!this->completion);
  323. this->completion = lub_string_dup(completion);
  324. }
  325. /*--------------------------------------------------------- */
  326. char *clish_param__get_completion(const clish_param_t *this)
  327. {
  328. return this->completion;
  329. }