1
0

param.c 9.3 KB

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