1
0

shell_tinyrl.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537
  1. /*
  2. * shell_tinyrl.c
  3. *
  4. * This is a specialisation of the tinyrl_t class which maps the readline
  5. * functionality to the CLISH environment.
  6. */
  7. #include "private.h"
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <assert.h>
  11. #include <string.h>
  12. #include <errno.h>
  13. #include <ctype.h>
  14. #include "tinyrl/tinyrl.h"
  15. #include "tinyrl/history.h"
  16. #include "lub/string.h"
  17. /*-------------------------------------------------------- */
  18. static void clish_shell_renew_prompt(tinyrl_t *this)
  19. {
  20. clish_context_t *context = tinyrl__get_context(this);
  21. char *prompt = NULL;
  22. const clish_view_t *view;
  23. /* Obtain the prompt */
  24. view = clish_shell__get_view(context->shell);
  25. assert(view);
  26. prompt = clish_shell_expand(clish_view__get_prompt(view), SHELL_VAR_ACTION, context);
  27. assert(prompt);
  28. tinyrl__set_prompt(this, prompt);
  29. lub_string_free(prompt);
  30. }
  31. /*-------------------------------------------------------- */
  32. static bool_t clish_shell_tinyrl_key_help(tinyrl_t * this, int key)
  33. {
  34. bool_t result = BOOL_TRUE;
  35. if (tinyrl_is_quoting(this)) {
  36. /* if we are in the middle of a quote then simply enter a space */
  37. result = tinyrl_insert_text(this, "?");
  38. } else {
  39. /* get the context */
  40. clish_context_t *context = tinyrl__get_context(this);
  41. tinyrl_crlf(this);
  42. clish_shell_help(context->shell, tinyrl__get_line(this));
  43. tinyrl_crlf(this);
  44. tinyrl_reset_line_state(this);
  45. }
  46. /* keep the compiler happy */
  47. key = key;
  48. return result;
  49. }
  50. /*lint +e818 */
  51. /*-------------------------------------------------------- */
  52. /*
  53. * Expand the current line with any history substitutions
  54. */
  55. static clish_pargv_status_t clish_shell_tinyrl_expand(tinyrl_t * this)
  56. {
  57. clish_pargv_status_t status = CLISH_LINE_OK;
  58. int rtn;
  59. char *buffer;
  60. /* first of all perform any history substitutions */
  61. rtn = tinyrl_history_expand(tinyrl__get_history(this),
  62. tinyrl__get_line(this), &buffer);
  63. switch (rtn) {
  64. case -1:
  65. /* error in expansion */
  66. status = CLISH_BAD_HISTORY;
  67. break;
  68. case 0:
  69. /*no expansion */
  70. break;
  71. case 1:
  72. /* expansion occured correctly */
  73. tinyrl_replace_line(this, buffer, 1);
  74. break;
  75. case 2:
  76. /* just display line */
  77. fprintf(tinyrl__get_ostream(this), "\n%s", buffer);
  78. free(buffer);
  79. buffer = NULL;
  80. break;
  81. default:
  82. break;
  83. }
  84. free(buffer);
  85. return status;
  86. }
  87. /*-------------------------------------------------------- */
  88. /*
  89. * This is a CLISH specific completion function.
  90. * If the current prefix is not a recognised prefix then
  91. * an error is flagged.
  92. * If it is a recognisable prefix then possible completions are displayed
  93. * or a unique completion is inserted.
  94. */
  95. static tinyrl_match_e clish_shell_tinyrl_complete(tinyrl_t * this)
  96. {
  97. /* context_t *context = tinyrl__get_context(this); */
  98. tinyrl_match_e status;
  99. /* first of all perform any history expansion */
  100. (void)clish_shell_tinyrl_expand(this);
  101. /* perform normal completion */
  102. status = tinyrl_complete(this);
  103. switch (status) {
  104. case TINYRL_NO_MATCH:
  105. if (BOOL_FALSE == tinyrl_is_completion_error_over(this)) {
  106. /* The user hasn't even entered a valid prefix! */
  107. /* tinyrl_crlf(this);
  108. clish_shell_help(context->shell,
  109. tinyrl__get_line(this));
  110. tinyrl_crlf(this);
  111. tinyrl_reset_line_state(this);
  112. */ }
  113. break;
  114. default:
  115. /* the default completion function will have prompted for completions as
  116. * necessary
  117. */
  118. break;
  119. }
  120. return status;
  121. }
  122. /*--------------------------------------------------------- */
  123. static bool_t clish_shell_tinyrl_key_space(tinyrl_t * this, int key)
  124. {
  125. bool_t result = BOOL_FALSE;
  126. tinyrl_match_e status;
  127. clish_context_t *context = tinyrl__get_context(this);
  128. const char *line = tinyrl__get_line(this);
  129. clish_pargv_status_t arg_status;
  130. const clish_command_t *cmd = NULL;
  131. clish_pargv_t *pargv = NULL;
  132. if(tinyrl_is_empty(this)) {
  133. /* ignore space at the begining of the line, don't display commands */
  134. return BOOL_TRUE;
  135. } else if (tinyrl_is_quoting(this)) {
  136. /* if we are in the middle of a quote then simply enter a space */
  137. result = BOOL_TRUE;
  138. } else {
  139. /* Find out if current line is legal. It can be
  140. * fully completed or partially completed.
  141. */
  142. arg_status = clish_shell_parse(context->shell,
  143. line, &cmd, &pargv);
  144. if (pargv)
  145. clish_pargv_delete(pargv);
  146. switch (arg_status) {
  147. case CLISH_LINE_OK:
  148. case CLISH_LINE_PARTIAL:
  149. if (' ' != line[strlen(line) - 1])
  150. result = BOOL_TRUE;
  151. break;
  152. default:
  153. break;
  154. }
  155. /* If current line is illegal try to make auto-comletion. */
  156. if (!result) {
  157. /* perform word completion */
  158. status = clish_shell_tinyrl_complete(this);
  159. switch (status) {
  160. case TINYRL_NO_MATCH:
  161. case TINYRL_AMBIGUOUS:
  162. /* ambiguous result signal an issue */
  163. break;
  164. case TINYRL_COMPLETED_AMBIGUOUS:
  165. /* perform word completion again in case we just did case
  166. modification the first time */
  167. status = clish_shell_tinyrl_complete(this);
  168. if (status == TINYRL_MATCH_WITH_EXTENSIONS) {
  169. /* all is well with the world just enter a space */
  170. result = BOOL_TRUE;
  171. }
  172. break;
  173. case TINYRL_MATCH:
  174. case TINYRL_MATCH_WITH_EXTENSIONS:
  175. case TINYRL_COMPLETED_MATCH:
  176. /* all is well with the world just enter a space */
  177. result = BOOL_TRUE;
  178. break;
  179. }
  180. }
  181. }
  182. if (result)
  183. result = tinyrl_insert_text(this, " ");
  184. /* keep compiler happy */
  185. key = key;
  186. return result;
  187. }
  188. /*-------------------------------------------------------- */
  189. static bool_t clish_shell_tinyrl_key_enter(tinyrl_t *this, int key)
  190. {
  191. clish_context_t *context = tinyrl__get_context(this);
  192. const clish_command_t *cmd = NULL;
  193. const char *line = tinyrl__get_line(this);
  194. bool_t result = BOOL_FALSE;
  195. /* Renew prompt */
  196. clish_shell_renew_prompt(this);
  197. /* nothing to pass simply move down the screen */
  198. if (!*line) {
  199. tinyrl_crlf(this);
  200. tinyrl_reset_line_state(this);
  201. return BOOL_TRUE;
  202. }
  203. /* try and parse the command */
  204. cmd = clish_shell_resolve_command(context->shell, line);
  205. if (!cmd) {
  206. tinyrl_match_e status = clish_shell_tinyrl_complete(this);
  207. switch (status) {
  208. case TINYRL_MATCH:
  209. case TINYRL_MATCH_WITH_EXTENSIONS:
  210. case TINYRL_COMPLETED_MATCH:
  211. /* re-fetch the line as it may have changed
  212. * due to auto-completion
  213. */
  214. line = tinyrl__get_line(this);
  215. /* get the command to parse? */
  216. cmd = clish_shell_resolve_command(context->shell, line);
  217. /*
  218. * We have had a match but it is not a command
  219. * so add a space so as not to confuse the user
  220. */
  221. if (!cmd)
  222. result = tinyrl_insert_text(this, " ");
  223. break;
  224. default:
  225. /* failed to get a unique match... */
  226. break;
  227. }
  228. }
  229. if (cmd) {
  230. clish_pargv_status_t arg_status;
  231. tinyrl_crlf(this);
  232. /* we've got a command so check the syntax */
  233. arg_status = clish_shell_parse(context->shell,
  234. line, &context->cmd, &context->pargv);
  235. switch (arg_status) {
  236. case CLISH_LINE_OK:
  237. tinyrl_done(this);
  238. result = BOOL_TRUE;
  239. break;
  240. case CLISH_BAD_HISTORY:
  241. fprintf(stderr, "Error: Bad history entry.\n");
  242. break;
  243. case CLISH_BAD_CMD:
  244. fprintf(stderr, "Error: Illegal command line.\n");
  245. break;
  246. case CLISH_BAD_PARAM:
  247. fprintf(stderr, "Error: Illegal parameter.\n");
  248. break;
  249. case CLISH_LINE_PARTIAL:
  250. fprintf(stderr, "Error: The command is not completed.\n");
  251. break;
  252. }
  253. if (CLISH_LINE_OK != arg_status)
  254. tinyrl_reset_line_state(this);
  255. }
  256. /* keep the compiler happy */
  257. key = key;
  258. return result;
  259. }
  260. /*-------------------------------------------------------- */
  261. /* This is the completion function provided for CLISH */
  262. tinyrl_completion_func_t clish_shell_tinyrl_completion;
  263. char **clish_shell_tinyrl_completion(tinyrl_t * tinyrl,
  264. const char *line, unsigned start, unsigned end)
  265. {
  266. lub_argv_t *matches = lub_argv_new(NULL, 0);
  267. clish_context_t *context = tinyrl__get_context(tinyrl);
  268. clish_shell_t *this = context->shell;
  269. clish_shell_iterator_t iter;
  270. const clish_command_t *cmd = NULL;
  271. char *text = lub_string_dupn(line, end);
  272. char **result = NULL;
  273. /* Don't bother to resort to filename completion */
  274. tinyrl_completion_over(tinyrl);
  275. /* Search for COMMAND completions */
  276. clish_shell_iterator_init(&iter, CLISH_NSPACE_COMPLETION);
  277. while ((cmd = clish_shell_find_next_completion(this, text, &iter)))
  278. lub_argv_add(matches, clish_command__get_suffix(cmd));
  279. /* Try and resolve a command */
  280. cmd = clish_shell_resolve_command(this, text);
  281. /* Search for PARAM completion */
  282. if (cmd)
  283. clish_shell_param_generator(this, matches, cmd, text, start);
  284. lub_string_free(text);
  285. /* Matches were found */
  286. if (lub_argv__get_count(matches) > 0) {
  287. unsigned i;
  288. char *subst = lub_string_dup(lub_argv__get_arg(matches, 0));
  289. /* Find out substitution */
  290. for (i = 1; i < lub_argv__get_count(matches); i++) {
  291. char *p = subst;
  292. const char *match = lub_argv__get_arg(matches, i);
  293. size_t match_len = strlen(p);
  294. /* identify the common prefix */
  295. while ((tolower(*p) == tolower(*match)) && match_len--) {
  296. p++;
  297. match++;
  298. }
  299. /* Terminate the prefix string */
  300. *p = '\0';
  301. }
  302. result = lub_argv__get_argv(matches, subst);
  303. lub_string_free(subst);
  304. }
  305. lub_argv_delete(matches);
  306. return result;
  307. }
  308. /*-------------------------------------------------------- */
  309. static void clish_shell_tinyrl_init(tinyrl_t * this)
  310. {
  311. bool_t status;
  312. /* bind the '?' key to the help function */
  313. status = tinyrl_bind_key(this, '?', clish_shell_tinyrl_key_help);
  314. assert(status);
  315. /* bind the <RET> key to the help function */
  316. status = tinyrl_bind_key(this, '\r', clish_shell_tinyrl_key_enter);
  317. assert(status);
  318. status = tinyrl_bind_key(this, '\n', clish_shell_tinyrl_key_enter);
  319. assert(status);
  320. /* bind the <SPACE> key to auto-complete if necessary */
  321. status = tinyrl_bind_key(this, ' ', clish_shell_tinyrl_key_space);
  322. assert(status);
  323. /* Assign timeout callback */
  324. tinyrl__set_timeout_fn(this, clish_shell_timeout_fn);
  325. /* Assign keypress callback */
  326. tinyrl__set_keypress_fn(this, clish_shell_keypress_fn);
  327. }
  328. /*-------------------------------------------------------- */
  329. /*
  330. * Create an instance of the specialised class
  331. */
  332. tinyrl_t *clish_shell_tinyrl_new(FILE * istream,
  333. FILE * ostream, unsigned stifle)
  334. {
  335. /* call the parent constructor */
  336. tinyrl_t *this = tinyrl_new(istream,
  337. ostream, stifle, clish_shell_tinyrl_completion);
  338. /* now call our own constructor */
  339. if (this)
  340. clish_shell_tinyrl_init(this);
  341. return this;
  342. }
  343. /*-------------------------------------------------------- */
  344. void clish_shell_tinyrl_fini(tinyrl_t * this)
  345. {
  346. /* nothing to do... yet */
  347. this = this;
  348. }
  349. /*-------------------------------------------------------- */
  350. void clish_shell_tinyrl_delete(tinyrl_t * this)
  351. {
  352. /* call our destructor */
  353. clish_shell_tinyrl_fini(this);
  354. /* and call the parent destructor */
  355. tinyrl_delete(this);
  356. }
  357. /*-------------------------------------------------------- */
  358. int clish_shell_execline(clish_shell_t *this, const char *line, char **out)
  359. {
  360. char *prompt = NULL;
  361. const clish_view_t *view;
  362. char *str;
  363. clish_context_t context;
  364. tinyrl_history_t *history;
  365. int lerror = 0;
  366. assert(this);
  367. this->state = SHELL_STATE_OK;
  368. if (!line && !tinyrl__get_istream(this->tinyrl)) {
  369. this->state = SHELL_STATE_SYSTEM_ERROR;
  370. return -1;
  371. }
  372. /* Set up the context for tinyrl */
  373. context.cmd = NULL;
  374. context.pargv = NULL;
  375. context.shell = this;
  376. /* Obtain the prompt */
  377. view = clish_shell__get_view(this);
  378. assert(view);
  379. prompt = clish_shell_expand(clish_view__get_prompt(view), SHELL_VAR_ACTION, &context);
  380. assert(prompt);
  381. /* Push the specified line or interactive line */
  382. if (line)
  383. str = tinyrl_forceline(this->tinyrl, prompt, &context, line);
  384. else
  385. str = tinyrl_readline(this->tinyrl, prompt, &context);
  386. lerror = errno;
  387. lub_string_free(prompt);
  388. if (!str) {
  389. switch (lerror) {
  390. case ENOENT:
  391. this->state = SHELL_STATE_EOF;
  392. break;
  393. case EBADMSG:
  394. this->state = SHELL_STATE_SYNTAX_ERROR;
  395. break;
  396. default:
  397. this->state = SHELL_STATE_SYSTEM_ERROR;
  398. break;
  399. };
  400. return -1;
  401. }
  402. /* Deal with the history list */
  403. if (tinyrl__get_isatty(this->tinyrl)) {
  404. history = tinyrl__get_history(this->tinyrl);
  405. tinyrl_history_add(history, str);
  406. }
  407. /* Let the client know the command line has been entered */
  408. if (this->client_hooks->cmd_line_fn)
  409. this->client_hooks->cmd_line_fn(&context, str);
  410. free(str);
  411. /* Execute the provided command */
  412. if (context.cmd && context.pargv) {
  413. int res;
  414. if ((res = clish_shell_execute(&context, out))) {
  415. this->state = SHELL_STATE_SCRIPT_ERROR;
  416. if (context.pargv)
  417. clish_pargv_delete(context.pargv);
  418. return res;
  419. }
  420. }
  421. if (context.pargv)
  422. clish_pargv_delete(context.pargv);
  423. return 0;
  424. }
  425. /*-------------------------------------------------------- */
  426. int clish_shell_forceline(clish_shell_t *this, const char *line, char **out)
  427. {
  428. return clish_shell_execline(this, line, out);
  429. }
  430. /*-------------------------------------------------------- */
  431. int clish_shell_readline(clish_shell_t *this, char **out)
  432. {
  433. return clish_shell_execline(this, NULL, out);
  434. }
  435. /*-------------------------------------------------------- */
  436. FILE * clish_shell__get_istream(const clish_shell_t * this)
  437. {
  438. return tinyrl__get_istream(this->tinyrl);
  439. }
  440. /*-------------------------------------------------------- */
  441. FILE * clish_shell__get_ostream(const clish_shell_t * this)
  442. {
  443. return tinyrl__get_ostream(this->tinyrl);
  444. }
  445. /*-------------------------------------------------------- */
  446. void clish_shell__set_interactive(clish_shell_t * this, bool_t interactive)
  447. {
  448. assert(this);
  449. this->interactive = interactive;
  450. }
  451. /*-------------------------------------------------------- */
  452. bool_t clish_shell__get_interactive(const clish_shell_t * this)
  453. {
  454. assert(this);
  455. return this->interactive;
  456. }
  457. /*-------------------------------------------------------- */
  458. bool_t clish_shell__get_utf8(const clish_shell_t * this)
  459. {
  460. assert(this);
  461. return tinyrl__get_utf8(this->tinyrl);
  462. }
  463. /*-------------------------------------------------------- */
  464. void clish_shell__set_utf8(clish_shell_t * this, bool_t utf8)
  465. {
  466. assert(this);
  467. tinyrl__set_utf8(this->tinyrl, utf8);
  468. }
  469. /*-------------------------------------------------------- */
  470. void clish_shell__set_timeout(clish_shell_t *this, int timeout)
  471. {
  472. assert(this);
  473. this->idle_timeout = timeout;
  474. }
  475. /*--------------------------------------------------------- */
  476. tinyrl_t *clish_shell__get_tinyrl(const clish_shell_t * this)
  477. {
  478. return this->tinyrl;
  479. }
  480. /*-------------------------------------------------------- */