1
0

tinyrl.c 41 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452
  1. /*
  2. * tinyrl.c
  3. */
  4. /* make sure we can get fileno() */
  5. #undef __STRICT_ANSI__
  6. /* LIBC HEADERS */
  7. #include <assert.h>
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <string.h>
  11. #include <ctype.h>
  12. /* POSIX HEADERS */
  13. #include <unistd.h>
  14. #include "lub/string.h"
  15. #include "private.h"
  16. /*----------------------------------------------------------------------- */
  17. static void
  18. tty_set_raw_mode(tinyrl_t *this)
  19. {
  20. struct termios new_termios;
  21. int fd = fileno(tinyrl_vt100__get_istream(this->term));
  22. int status;
  23. status = tcgetattr(fd,&this->default_termios);
  24. if(-1 != status)
  25. {
  26. status = tcgetattr(fd,&new_termios);
  27. assert(-1 != status);
  28. new_termios.c_iflag = 0;
  29. new_termios.c_oflag = OPOST | ONLCR;
  30. new_termios.c_lflag = 0;
  31. new_termios.c_cc[VMIN] = 1;
  32. new_termios.c_cc[VTIME] = 0;
  33. /* Do the mode switch */
  34. status = tcsetattr(fd,TCSAFLUSH,&new_termios);
  35. assert(-1 != status);
  36. }
  37. }
  38. /*----------------------------------------------------------------------- */
  39. static void
  40. tty_restore_mode(const tinyrl_t *this)
  41. {
  42. int fd = fileno(tinyrl_vt100__get_istream(this->term));
  43. /* Do the mode switch */
  44. (void)tcsetattr(fd,TCSAFLUSH,&this->default_termios);
  45. }
  46. /*----------------------------------------------------------------------- */
  47. /*
  48. This is called whenever a line is edited in any way.
  49. It signals that if we are currently viewing a history line we should transfer it
  50. to the current buffer
  51. */
  52. static void
  53. changed_line(tinyrl_t *this)
  54. {
  55. /* if the current line is not our buffer then make it so */
  56. if(this->line != this->buffer)
  57. {
  58. /* replace the current buffer with the new details */
  59. free(this->buffer);
  60. this->line = this->buffer = lub_string_dup(this->line);
  61. this->buffer_size = strlen(this->buffer);
  62. assert(this->line);
  63. }
  64. }
  65. /*----------------------------------------------------------------------- */
  66. static bool_t
  67. tinyrl_key_default(tinyrl_t *this,
  68. int key)
  69. {
  70. bool_t result = BOOL_FALSE;
  71. if(key > 31)
  72. {
  73. char tmp[2];
  74. tmp[0] = (key & 0xFF),
  75. tmp[1] = '\0';
  76. /* inject this text into the buffer */
  77. result = tinyrl_insert_text(this,tmp);
  78. }
  79. else
  80. {
  81. char tmp[10];
  82. sprintf(tmp,"~%d",key);
  83. /* inject control characters as ~N where N is the ASCII code */
  84. result = tinyrl_insert_text(this,tmp);
  85. }
  86. return result;
  87. }
  88. /*-------------------------------------------------------- */
  89. static bool_t
  90. tinyrl_key_interrupt(tinyrl_t *this,
  91. int key)
  92. {
  93. tinyrl_delete_text(this,0,this->end);
  94. this->done = BOOL_TRUE;
  95. /* keep the compiler happy */
  96. key = key;
  97. return BOOL_TRUE;
  98. }
  99. /*-------------------------------------------------------- */
  100. static bool_t
  101. tinyrl_key_start_of_line(tinyrl_t *this,
  102. int key)
  103. {
  104. /* set the insertion point to the start of the line */
  105. this->point = 0;
  106. /* keep the compiler happy */
  107. key = key;
  108. return BOOL_TRUE;
  109. }
  110. /*-------------------------------------------------------- */
  111. static bool_t
  112. tinyrl_key_end_of_line(tinyrl_t *this,
  113. int key)
  114. {
  115. /* set the insertion point to the end of the line */
  116. this->point = this->end;
  117. /* keep the compiler happy */
  118. key = key;
  119. return BOOL_TRUE;
  120. }
  121. /*-------------------------------------------------------- */
  122. static bool_t
  123. tinyrl_key_kill(tinyrl_t *this,
  124. int key)
  125. {
  126. /* release any old kill string */
  127. lub_string_free(this->kill_string);
  128. /* store the killed string */
  129. this->kill_string = lub_string_dup(&this->buffer[this->point]);
  130. /* delete the text to the end of the line */
  131. tinyrl_delete_text(this,this->point,this->end);
  132. /* keep the compiler happy */
  133. key = key;
  134. return BOOL_TRUE;
  135. }
  136. /*-------------------------------------------------------- */
  137. static bool_t
  138. tinyrl_key_yank(tinyrl_t *this,
  139. int key)
  140. {
  141. bool_t result = BOOL_FALSE;
  142. if(this->kill_string)
  143. {
  144. /* insert the kill string at the current insertion point */
  145. result = tinyrl_insert_text(this,this->kill_string);
  146. }
  147. /* keep the compiler happy */
  148. key = key;
  149. return result;
  150. }
  151. /*-------------------------------------------------------- */
  152. static bool_t
  153. tinyrl_key_crlf(tinyrl_t *this,
  154. int key)
  155. {
  156. tinyrl_crlf(this);
  157. this->done = BOOL_TRUE;
  158. /* keep the compiler happy */
  159. key = key;
  160. return BOOL_TRUE;
  161. }
  162. /*-------------------------------------------------------- */
  163. static bool_t
  164. tinyrl_key_up(tinyrl_t *this,
  165. int key)
  166. {
  167. bool_t result = BOOL_FALSE;
  168. tinyrl_history_entry_t *entry = NULL;
  169. if(this->line == this->buffer)
  170. {
  171. /* go to the last history entry */
  172. entry = tinyrl_history_getlast(this->history,
  173. &this->hist_iter);
  174. }
  175. else
  176. {
  177. /* already traversing the history list so get previous */
  178. entry = tinyrl_history_getprevious(&this->hist_iter);
  179. }
  180. if(NULL != entry)
  181. {
  182. /* display the entry moving the insertion point
  183. * to the end of the line
  184. */
  185. this->line = tinyrl_history_entry__get_line(entry);
  186. this->point = this->end = strlen(this->line);
  187. result = BOOL_TRUE;
  188. }
  189. /* keep the compiler happy */
  190. key = key;
  191. return result;
  192. }
  193. /*-------------------------------------------------------- */
  194. static bool_t
  195. tinyrl_key_down(tinyrl_t *this,
  196. int key)
  197. {
  198. bool_t result = BOOL_FALSE;
  199. if(this->line != this->buffer)
  200. {
  201. /* we are not already at the bottom */
  202. /* the iterator will have been set up by the key_up() function */
  203. tinyrl_history_entry_t *entry = tinyrl_history_getnext(&this->hist_iter);
  204. if(NULL == entry)
  205. {
  206. /* nothing more in the history list */
  207. this->line = this->buffer;
  208. }
  209. else
  210. {
  211. this->line = tinyrl_history_entry__get_line(entry);
  212. }
  213. /* display the entry moving the insertion point
  214. * to the end of the line
  215. */
  216. this->point = this->end = strlen(this->line);
  217. result = BOOL_TRUE;
  218. }
  219. /* keep the compiler happy */
  220. key = key;
  221. return result;
  222. }
  223. /*-------------------------------------------------------- */
  224. static bool_t
  225. tinyrl_key_left(tinyrl_t *this,
  226. int key)
  227. {
  228. bool_t result = BOOL_FALSE;
  229. if(this->point > 0)
  230. {
  231. this->point--;
  232. result = BOOL_TRUE;
  233. }
  234. /* keep the compiler happy */
  235. key = key;
  236. return result;
  237. }
  238. /*-------------------------------------------------------- */
  239. static bool_t
  240. tinyrl_key_right(tinyrl_t *this,
  241. int key)
  242. {
  243. bool_t result = BOOL_FALSE;
  244. if(this->point < this->end)
  245. {
  246. this->point++;
  247. result = BOOL_TRUE;
  248. }
  249. /* keep the compiler happy */
  250. key = key;
  251. return result;
  252. }
  253. /*-------------------------------------------------------- */
  254. static bool_t
  255. tinyrl_key_backspace(tinyrl_t *this,
  256. int key)
  257. {
  258. bool_t result = BOOL_FALSE;
  259. if(this->point)
  260. {
  261. this->point--;
  262. tinyrl_delete_text(this,this->point,this->point);
  263. result = BOOL_TRUE;
  264. }
  265. /* keep the compiler happy */
  266. key = key;
  267. return result;
  268. }
  269. /*-------------------------------------------------------- */
  270. static bool_t
  271. tinyrl_key_delete(tinyrl_t *this,
  272. int key)
  273. {
  274. bool_t result = BOOL_FALSE;
  275. if(this->point < this->end)
  276. {
  277. tinyrl_delete_text(this,this->point,this->point);
  278. result = BOOL_TRUE;
  279. }
  280. /* keep the compiler happy */
  281. key = key;
  282. return result;
  283. }
  284. /*-------------------------------------------------------- */
  285. static bool_t
  286. tinyrl_key_clear_screen(tinyrl_t *this,
  287. int key)
  288. {
  289. tinyrl_vt100_clear_screen(this->term);
  290. tinyrl_vt100_cursor_home(this->term);
  291. tinyrl_reset_line_state(this);
  292. /* keep the compiler happy */
  293. key = key;
  294. this = this;
  295. return BOOL_TRUE;
  296. }
  297. /*-------------------------------------------------------- */
  298. static bool_t
  299. tinyrl_key_erase_line(tinyrl_t *this, int key)
  300. {
  301. tinyrl_delete_text(this,0,this->point);
  302. this->point = 0;
  303. /* keep the compiler happy */
  304. key = key;
  305. this = this;
  306. return BOOL_TRUE;
  307. }/*-------------------------------------------------------- */
  308. static bool_t
  309. tinyrl_key_escape(tinyrl_t *this,
  310. int key)
  311. {
  312. bool_t result= BOOL_FALSE;
  313. switch(tinyrl_vt100_escape_decode(this->term))
  314. {
  315. case tinyrl_vt100_CURSOR_UP:
  316. result = tinyrl_key_up(this,key);
  317. break;
  318. case tinyrl_vt100_CURSOR_DOWN:
  319. result = tinyrl_key_down(this,key);
  320. break;
  321. case tinyrl_vt100_CURSOR_LEFT:
  322. result = tinyrl_key_left(this,key);
  323. break;
  324. case tinyrl_vt100_CURSOR_RIGHT:
  325. result = tinyrl_key_right(this,key);
  326. break;
  327. case tinyrl_vt100_UNKNOWN:
  328. break;
  329. }
  330. return result;
  331. }
  332. /*-------------------------------------------------------- */
  333. static bool_t
  334. tinyrl_key_tab(tinyrl_t *this,
  335. int key)
  336. {
  337. bool_t result = BOOL_FALSE;
  338. tinyrl_match_e status = tinyrl_complete_with_extensions(this);
  339. switch(status)
  340. {
  341. case TINYRL_COMPLETED_MATCH:
  342. case TINYRL_MATCH:
  343. {
  344. /* everything is OK with the world... */
  345. result = tinyrl_insert_text(this," ");
  346. break;
  347. }
  348. case TINYRL_NO_MATCH:
  349. case TINYRL_MATCH_WITH_EXTENSIONS:
  350. case TINYRL_AMBIGUOUS:
  351. case TINYRL_COMPLETED_AMBIGUOUS:
  352. {
  353. /* oops don't change the result and let the bell ring */
  354. break;
  355. }
  356. }
  357. /* keep the compiler happy */
  358. key = key;
  359. return result;
  360. }
  361. /*-------------------------------------------------------- */
  362. static void
  363. tinyrl_fini(tinyrl_t *this)
  364. {
  365. /* delete the history session */
  366. tinyrl_history_delete(this->history);
  367. /* delete the terminal session */
  368. tinyrl_vt100_delete(this->term);
  369. /* free up any dynamic strings */
  370. lub_string_free(this->buffer);
  371. this->buffer = NULL;
  372. lub_string_free(this->kill_string);
  373. this->kill_string = NULL;
  374. lub_string_free(this->last_buffer);
  375. this->last_buffer = NULL;
  376. }
  377. /*-------------------------------------------------------- */
  378. static void
  379. tinyrl_init(tinyrl_t *this,
  380. FILE *instream,
  381. FILE *outstream,
  382. unsigned stifle,
  383. tinyrl_completion_func_t *complete_fn)
  384. {
  385. int i;
  386. for(i = 0;i < NUM_HANDLERS; i++)
  387. {
  388. this->handlers[i] = tinyrl_key_default;
  389. }
  390. /* default handlers */
  391. this->handlers[KEY_CR] = tinyrl_key_crlf;
  392. this->handlers[KEY_LF] = tinyrl_key_crlf;
  393. this->handlers[KEY_ETX] = tinyrl_key_interrupt;
  394. this->handlers[KEY_DEL] = tinyrl_key_backspace;
  395. this->handlers[KEY_BS] = tinyrl_key_backspace;
  396. this->handlers[KEY_EOT] = tinyrl_key_delete;
  397. this->handlers[KEY_ESC] = tinyrl_key_escape;
  398. this->handlers[KEY_FF] = tinyrl_key_clear_screen;
  399. this->handlers[KEY_NAK] = tinyrl_key_erase_line;
  400. this->handlers[KEY_SOH] = tinyrl_key_start_of_line;
  401. this->handlers[KEY_ENQ] = tinyrl_key_end_of_line;
  402. this->handlers[KEY_VT] = tinyrl_key_kill;
  403. this->handlers[KEY_EM] = tinyrl_key_yank;
  404. this->handlers[KEY_HT] = tinyrl_key_tab;
  405. this->line = NULL;
  406. this->max_line_length = 0;
  407. this->prompt = NULL;
  408. this->prompt_size = 0;
  409. this->buffer = NULL;
  410. this->buffer_size = 0;
  411. this->done = BOOL_FALSE;
  412. this->completion_over = BOOL_FALSE;
  413. this->point = 0;
  414. this->end = 0;
  415. this->attempted_completion_function = complete_fn;
  416. this->state = 0;
  417. this->kill_string = NULL;
  418. this->echo_char = '\0';
  419. this->echo_enabled = BOOL_TRUE;
  420. if (instream)
  421. this->isatty = isatty(fileno(instream)) ? BOOL_TRUE : BOOL_FALSE;
  422. else
  423. this->isatty = BOOL_FALSE;
  424. this->last_buffer = NULL;
  425. this->last_point = 0;
  426. /* create the vt100 terminal */
  427. this->term = tinyrl_vt100_new(instream,outstream);
  428. /* create the history */
  429. this->history = tinyrl_history_new(stifle);
  430. }
  431. /*-------------------------------------------------------- */
  432. int
  433. tinyrl_printf(const tinyrl_t *this,
  434. const char *fmt,
  435. ...)
  436. {
  437. va_list args;
  438. int len;
  439. va_start(args, fmt);
  440. len = tinyrl_vt100_vprintf(this->term, fmt, args);
  441. va_end(args);
  442. return len;
  443. }
  444. /*-------------------------------------------------------- */
  445. void
  446. tinyrl_delete(tinyrl_t *this)
  447. {
  448. assert(this);
  449. if(this)
  450. {
  451. /* let the object tidy itself up */
  452. tinyrl_fini(this);
  453. /* release the memory associate with this instance */
  454. free(this);
  455. }
  456. }
  457. /*-------------------------------------------------------- */
  458. /*#####################################
  459. * EXPORTED INTERFACE
  460. *##################################### */
  461. /*----------------------------------------------------------------------- */
  462. int
  463. tinyrl_getchar(const tinyrl_t *this)
  464. {
  465. return tinyrl_vt100_getchar(this->term);
  466. }
  467. /*----------------------------------------------------------------------- */
  468. static void
  469. tinyrl_internal_print(const tinyrl_t *this,
  470. const char *text)
  471. {
  472. if(BOOL_TRUE == this->echo_enabled)
  473. {
  474. /* simply echo the line */
  475. tinyrl_vt100_printf(this->term,"%s",text);
  476. }
  477. else
  478. {
  479. /* replace the line with echo char if defined */
  480. if(this->echo_char)
  481. {
  482. unsigned i = strlen(text);
  483. while(i--)
  484. {
  485. tinyrl_vt100_printf(this->term,"%c",this->echo_char);
  486. }
  487. }
  488. }
  489. }
  490. /*----------------------------------------------------------------------- */
  491. void
  492. tinyrl_redisplay(tinyrl_t *this)
  493. {
  494. int delta;
  495. unsigned line_len, last_line_len,count;
  496. line_len = strlen(this->line);
  497. last_line_len = (this->last_buffer ? strlen(this->last_buffer) : 0);
  498. do
  499. {
  500. if(this->last_buffer)
  501. {
  502. delta = (int)(line_len - last_line_len);
  503. if(delta > 0)
  504. {
  505. count = (unsigned)delta;
  506. /* is the current line simply an extension of the previous one? */
  507. if(0 == strncmp(this->line,this->last_buffer,last_line_len))
  508. {
  509. /* output the line accounting for the echo behaviour */
  510. tinyrl_internal_print(this,&this->line[line_len - count]);
  511. break;
  512. }
  513. }
  514. else if(delta < 0)
  515. {
  516. /* is the current line simply a deletion of some characters from the end? */
  517. if(0 == strncmp(this->line,this->last_buffer,line_len))
  518. {
  519. if(this->echo_enabled || this->echo_char)
  520. {
  521. int shift = (int)(this->last_point - this->point);
  522. /* just get the terminal to delete the characters */
  523. if(shift > 0)
  524. {
  525. count = (unsigned)shift;
  526. /* we've moved the cursor backwards */
  527. tinyrl_vt100_cursor_back(this->term,count);
  528. }
  529. else if(shift < 0)
  530. {
  531. count = (unsigned)-shift;
  532. /* we've moved the cursor forwards */
  533. tinyrl_vt100_cursor_forward(this->term,count);
  534. }
  535. /* now delete the characters */
  536. count = (unsigned)-delta;
  537. tinyrl_vt100_erase(this->term,count);
  538. }
  539. break;
  540. }
  541. }
  542. else
  543. {
  544. /* are the lines are the same content? */
  545. if(0 == strcmp(this->line,this->last_buffer))
  546. {
  547. if(this->echo_enabled || this->echo_char)
  548. {
  549. delta = (int)(this->point - this->last_point);
  550. if(delta > 0)
  551. {
  552. count = (unsigned)delta;
  553. /* move the point forwards */
  554. tinyrl_vt100_cursor_forward(this->term,count);
  555. }
  556. else if(delta < 0)
  557. {
  558. count = (unsigned)-delta;
  559. /* move the cursor backwards */
  560. tinyrl_vt100_cursor_back(this->term,count);
  561. }
  562. }
  563. /* done for now */
  564. break;
  565. }
  566. }
  567. }
  568. else
  569. {
  570. /* simply display the prompt and the line */
  571. tinyrl_vt100_printf(this->term,"%s",this->prompt);
  572. tinyrl_internal_print(this,this->line);
  573. if(this->point < line_len)
  574. {
  575. /* move the cursor to the insertion point */
  576. tinyrl_vt100_cursor_back(this->term,line_len-this->point);
  577. }
  578. break;
  579. }
  580. /*
  581. * to have got this far we must have edited the middle of a line.
  582. */
  583. if(this->last_point)
  584. {
  585. /* move to just after the prompt of the line */
  586. tinyrl_vt100_cursor_back(this->term,this->last_point);
  587. }
  588. /* erase the previous line */
  589. tinyrl_vt100_erase(this->term,strlen(this->last_buffer));
  590. /* output the line accounting for the echo behaviour */
  591. tinyrl_internal_print(this,this->line);
  592. delta = (int)(line_len - this->point);
  593. if(delta)
  594. {
  595. /* move the cursor back to the insertion point */
  596. tinyrl_vt100_cursor_back(this->term,
  597. (strlen(this->line) - this->point));
  598. }
  599. } /*lint -e717 */ while(0) /*lint +e717 */;
  600. /* update the display */
  601. (void)tinyrl_vt100_oflush(this->term);
  602. /* set up the last line buffer */
  603. lub_string_free(this->last_buffer);
  604. this->last_buffer = lub_string_dup(this->line);
  605. this->last_point = this->point;
  606. }
  607. /*----------------------------------------------------------------------- */
  608. tinyrl_t *
  609. tinyrl_new(FILE *instream,
  610. FILE *outstream,
  611. unsigned stifle,
  612. tinyrl_completion_func_t *complete_fn)
  613. {
  614. tinyrl_t *this=NULL;
  615. this = malloc(sizeof(tinyrl_t));
  616. if(NULL != this)
  617. {
  618. tinyrl_init(this,instream,outstream,stifle,complete_fn);
  619. }
  620. return this;
  621. }
  622. /*----------------------------------------------------------------------- */
  623. static char *
  624. internal_insertline(tinyrl_t *this,
  625. char *buffer)
  626. {
  627. char *p;
  628. char *s = buffer;
  629. /* strip any spurious '\r' or '\n' */
  630. p = strchr(buffer,'\r');
  631. if(NULL == p)
  632. {
  633. p = strchr(buffer,'\n');
  634. }
  635. if (NULL != p)
  636. {
  637. *p = '\0';
  638. }
  639. /* skip any whitespace at the beginning of the line */
  640. if(0 == this->point)
  641. {
  642. while(*s && isspace(*s))
  643. {
  644. s++;
  645. }
  646. }
  647. if(*s)
  648. {
  649. /* append this string to the input buffer */
  650. (void) tinyrl_insert_text(this,s);
  651. /* echo the command to the output stream */
  652. tinyrl_redisplay(this);
  653. }
  654. return s;
  655. }
  656. /*----------------------------------------------------------------------- */
  657. static char *
  658. internal_readline(tinyrl_t *this,
  659. const char *prompt,
  660. void *context,
  661. const char *str)
  662. {
  663. FILE *istream = tinyrl_vt100__get_istream(this->term);
  664. /* initialise for reading a line */
  665. this->done = BOOL_FALSE;
  666. this->point = 0;
  667. this->end = 0;
  668. this->buffer = lub_string_dup("");
  669. this->buffer_size = strlen(this->buffer);
  670. this->line = this->buffer;
  671. this->prompt = prompt;
  672. this->prompt_size = strlen(prompt);
  673. this->context = context;
  674. if((BOOL_TRUE == this->isatty) && (!str))
  675. {
  676. /* set the terminal into raw input mode */
  677. tty_set_raw_mode(this);
  678. tinyrl_reset_line_state(this);
  679. while(!this->done)
  680. {
  681. int key;
  682. /* update the display */
  683. tinyrl_redisplay(this);
  684. /* get a key */
  685. key = tinyrl_getchar(this);
  686. /* has the input stream terminated? */
  687. if(EOF != key)
  688. {
  689. /* call the handler for this key */
  690. if(BOOL_FALSE == this->handlers[key](this,key))
  691. {
  692. /* an issue has occured */
  693. tinyrl_ding(this);
  694. }
  695. if (BOOL_TRUE == this->done)
  696. {
  697. /*
  698. * If the last character in the line (other than
  699. * the null) is a space remove it.
  700. */
  701. if (this->end && isspace(this->line[this->end-1]))
  702. {
  703. tinyrl_delete_text(this,this->end-1,this->end);
  704. }
  705. }
  706. }
  707. else
  708. {
  709. /* time to finish the session */
  710. this->done = BOOL_TRUE;
  711. this->line = NULL;
  712. }
  713. }
  714. /* restores the terminal mode */
  715. tty_restore_mode(this);
  716. }
  717. else
  718. {
  719. /* This is a non-interactive set of commands */
  720. char *s = 0, buffer[80];
  721. size_t len = sizeof(buffer);
  722. char *tmp = NULL;
  723. /* manually reset the line state without redisplaying */
  724. lub_string_free(this->last_buffer);
  725. this->last_buffer = NULL;
  726. if (str) {
  727. tmp = lub_string_dup(str);
  728. s = internal_insertline(this, tmp);
  729. } else {
  730. while((sizeof(buffer) == len) &&
  731. (s = fgets(buffer,sizeof(buffer),istream)))
  732. {
  733. s = internal_insertline(this, buffer);
  734. len = strlen(buffer) + 1; /* account for the '\0' */
  735. }
  736. }
  737. /*
  738. * check against fgets returning null as either error or end of file.
  739. * This is a measure to stop potential task spin on encountering an
  740. * error from fgets.
  741. */
  742. if( s == NULL || (this->line[0] == '\0' && feof(istream)) )
  743. {
  744. /* time to finish the session */
  745. this->line = NULL;
  746. }
  747. else
  748. {
  749. /* call the handler for the newline key */
  750. if(BOOL_FALSE == this->handlers[KEY_LF](this,KEY_LF))
  751. {
  752. /* an issue has occured */
  753. tinyrl_ding(this);
  754. this->line = NULL;
  755. }
  756. }
  757. if (str)
  758. lub_string_free(tmp);
  759. }
  760. /*
  761. * duplicate the string for return to the client
  762. * we have to duplicate as we may be referencing a
  763. * history entry or our internal buffer
  764. */
  765. {
  766. char *result = this->line ? lub_string_dup(this->line) : NULL;
  767. /* free our internal buffer */
  768. free(this->buffer);
  769. this->buffer = NULL;
  770. if((NULL == result) || '\0' == *result)
  771. {
  772. /* make sure we're not left on a prompt line */
  773. tinyrl_crlf(this);
  774. }
  775. return result;
  776. }
  777. }
  778. /*----------------------------------------------------------------------- */
  779. char *
  780. tinyrl_readline(tinyrl_t *this,
  781. const char *prompt,
  782. void *context)
  783. {
  784. return internal_readline(this, prompt, context, NULL);
  785. }
  786. /*----------------------------------------------------------------------- */
  787. char *
  788. tinyrl_forceline(tinyrl_t *this,
  789. const char *prompt,
  790. void *context,
  791. const char *line)
  792. {
  793. return internal_readline(this, prompt, context, line);
  794. }
  795. /*----------------------------------------------------------------------- */
  796. /*
  797. * Ensure that buffer has enough space to hold len characters,
  798. * possibly reallocating it if necessary. The function returns BOOL_TRUE
  799. * if the line is successfully extended, BOOL_FALSE if not.
  800. */
  801. bool_t
  802. tinyrl_extend_line_buffer(tinyrl_t *this,
  803. unsigned len)
  804. {
  805. bool_t result = BOOL_TRUE;
  806. if(this->buffer_size < len)
  807. {
  808. char * new_buffer;
  809. size_t new_len = len;
  810. /*
  811. * What we do depends on whether we are limited by
  812. * memory or a user imposed limit.
  813. */
  814. if (this->max_line_length == 0)
  815. {
  816. if(new_len < this->buffer_size + 10)
  817. {
  818. /* make sure we don't realloc too often */
  819. new_len = this->buffer_size + 10;
  820. }
  821. /* leave space for terminator */
  822. new_buffer = realloc(this->buffer,new_len+1);
  823. if(NULL == new_buffer)
  824. {
  825. tinyrl_ding(this);
  826. result = BOOL_FALSE;
  827. }
  828. else
  829. {
  830. this->buffer_size = new_len;
  831. this->line = this->buffer = new_buffer;
  832. }
  833. }
  834. else
  835. {
  836. if(new_len < this->max_line_length)
  837. {
  838. /* Just reallocate once to the max size */
  839. new_buffer = realloc(this->buffer,this->max_line_length);
  840. if(NULL == new_buffer)
  841. {
  842. tinyrl_ding(this);
  843. result = BOOL_FALSE;
  844. }
  845. else
  846. {
  847. this->buffer_size = this->max_line_length - 1;
  848. this->line = this->buffer = new_buffer;
  849. }
  850. }
  851. else
  852. {
  853. tinyrl_ding(this);
  854. result = BOOL_FALSE;
  855. }
  856. }
  857. }
  858. return result;
  859. }
  860. /*----------------------------------------------------------------------- */
  861. /*
  862. * Insert text into the line at the current cursor position.
  863. */
  864. bool_t
  865. tinyrl_insert_text(tinyrl_t *this,
  866. const char *text)
  867. {
  868. unsigned delta = strlen(text);
  869. /*
  870. * If the client wants to change the line ensure that the line and buffer
  871. * references are in sync
  872. */
  873. changed_line(this);
  874. if((delta + this->end) > (this->buffer_size))
  875. {
  876. /* extend the current buffer */
  877. if (BOOL_FALSE == tinyrl_extend_line_buffer(this,this->end + delta))
  878. {
  879. return BOOL_FALSE;
  880. }
  881. }
  882. if(this->point < this->end)
  883. {
  884. /* move the current text to the right (including the terminator) */
  885. memmove(&this->buffer[this->point+delta],
  886. &this->buffer[this->point],
  887. (this->end - this->point) + 1);
  888. }
  889. else
  890. {
  891. /* terminate the string */
  892. this->buffer[this->end+delta] = '\0';
  893. }
  894. /* insert the new text */
  895. strncpy(&this->buffer[this->point],text,delta);
  896. /* now update the indexes */
  897. this->point += delta;
  898. this->end += delta;
  899. return BOOL_TRUE;
  900. }
  901. /*----------------------------------------------------------------------- */
  902. /*
  903. * A convenience function for displaying a list of strings in columnar
  904. * format on Readline's output stream. matches is the list of strings,
  905. * in argv format, such as a list of completion matches. len is the number
  906. * of strings in matches, and max is the length of the longest string in matches.
  907. * This function uses the setting of print-completions-horizontally to select
  908. * how the matches are displayed
  909. */
  910. void
  911. tinyrl_display_matches(const tinyrl_t *this,
  912. char *const *matches,
  913. unsigned len,
  914. size_t max)
  915. {
  916. unsigned r,c;
  917. unsigned width = tinyrl_vt100__get_width(this->term);
  918. unsigned cols = width/(max+1); /* allow for a space between words */
  919. unsigned rows = len/cols + 1;
  920. assert(matches);
  921. if(matches)
  922. {
  923. len--,matches++; /* skip the subtitution string */
  924. /* print out a table of completions */
  925. for(r=0; r<rows && len; r++)
  926. {
  927. for(c=0; c<cols && len; c++)
  928. {
  929. const char *match = *matches++;
  930. len--;
  931. tinyrl_vt100_printf(this->term,"%-*s ",max,match);
  932. }
  933. tinyrl_crlf(this);
  934. }
  935. }
  936. }
  937. /*----------------------------------------------------------------------- */
  938. /*
  939. * Delete the text between start and end in the current line. (inclusive)
  940. * This adjusts the rl_point and rl_end indexes appropriately.
  941. */
  942. void
  943. tinyrl_delete_text(tinyrl_t *this,
  944. unsigned start,
  945. unsigned end)
  946. {
  947. unsigned delta;
  948. /*
  949. * If the client wants to change the line ensure that the line and buffer
  950. * references are in sync
  951. */
  952. changed_line(this);
  953. /* make sure we play it safe */
  954. if(start > end)
  955. {
  956. unsigned tmp = end;
  957. start = end;
  958. end = tmp;
  959. }
  960. if(end > this->end)
  961. {
  962. end = this->end;
  963. }
  964. delta = (end - start) + 1;
  965. /* move any text which is left */
  966. memmove(&this->buffer[start],
  967. &this->buffer[start+delta],
  968. this->end - end);
  969. /* now adjust the indexs */
  970. if(this->point >= start)
  971. {
  972. if(this->point > end)
  973. {
  974. /* move the insertion point back appropriately */
  975. this->point -= delta;
  976. }
  977. else
  978. {
  979. /* move the insertion point to the start */
  980. this->point = start;
  981. }
  982. }
  983. if(this->end > end)
  984. {
  985. this->end -= delta;
  986. }
  987. else
  988. {
  989. this->end = start;
  990. }
  991. /* put a terminator at the end of the buffer */
  992. this->buffer[this->end] ='\0';
  993. }
  994. /*----------------------------------------------------------------------- */
  995. bool_t
  996. tinyrl_bind_key(tinyrl_t *this,
  997. int key,
  998. tinyrl_key_func_t *fn)
  999. {
  1000. bool_t result = BOOL_FALSE;
  1001. if((key >= 0) && (key < 256))
  1002. {
  1003. /* set the key handling function */
  1004. this->handlers[key] = fn;
  1005. result = BOOL_TRUE;
  1006. }
  1007. return result;
  1008. }
  1009. /*-------------------------------------------------------- */
  1010. /*
  1011. * Returns an array of strings which is a list of completions for text.
  1012. * If there are no completions, returns NULL. The first entry in the
  1013. * returned array is the substitution for text. The remaining entries
  1014. * are the possible completions. The array is terminated with a NULL pointer.
  1015. *
  1016. * entry_func is a function of two args, and returns a char *.
  1017. * The first argument is text. The second is a state argument;
  1018. * it is zero on the first call, and non-zero on subsequent calls.
  1019. * entry_func returns a NULL pointer to the caller when there are no
  1020. * more matches.
  1021. */
  1022. char **
  1023. tinyrl_completion(tinyrl_t *this,
  1024. const char *line,
  1025. unsigned start,
  1026. unsigned end,
  1027. tinyrl_compentry_func_t *entry_func)
  1028. {
  1029. unsigned state = 0;
  1030. size_t size = 1;
  1031. unsigned offset = 1; /* need at least one entry for the substitution */
  1032. char **matches = NULL;
  1033. char *match;
  1034. /* duplicate the string upto the insertion point */
  1035. char *text = lub_string_dupn(line,end);
  1036. /* now try and find possible completions */
  1037. while( (match = entry_func(this,text,start,state++)) )
  1038. {
  1039. if(size == offset)
  1040. {
  1041. /* resize the buffer if needed - the +1 is for the NULL terminator */
  1042. size += 10;
  1043. matches = realloc(matches,(sizeof(char *) * (size + 1)));
  1044. }
  1045. if (NULL == matches)
  1046. {
  1047. /* not much we can do... */
  1048. break;
  1049. }
  1050. matches[offset] = match;
  1051. /*
  1052. * augment the substitute string with this entry
  1053. */
  1054. if(1 == offset)
  1055. {
  1056. /* let's be optimistic */
  1057. matches[0] = lub_string_dup(match);
  1058. }
  1059. else
  1060. {
  1061. char *p = matches[0];
  1062. size_t match_len = strlen(p);
  1063. /* identify the common prefix */
  1064. while((tolower(*p) == tolower(*match)) && match_len--)
  1065. {
  1066. p++,match++;
  1067. }
  1068. /* terminate the prefix string */
  1069. *p = '\0';
  1070. }
  1071. offset++;
  1072. }
  1073. /* be a good memory citizen */
  1074. lub_string_free(text);
  1075. if(matches)
  1076. {
  1077. matches[offset] = NULL;
  1078. }
  1079. return matches;
  1080. }
  1081. /*-------------------------------------------------------- */
  1082. void
  1083. tinyrl_delete_matches(char **this)
  1084. {
  1085. char **matches = this;
  1086. while(*matches)
  1087. {
  1088. /* release the memory for each contained string */
  1089. free(*matches++);
  1090. }
  1091. /* release the memory for the array */
  1092. free(this);
  1093. }
  1094. /*-------------------------------------------------------- */
  1095. void
  1096. tinyrl_crlf(const tinyrl_t *this)
  1097. {
  1098. tinyrl_vt100_printf(this->term,"\n");
  1099. }
  1100. /*-------------------------------------------------------- */
  1101. /*
  1102. * Ring the terminal bell, obeying the setting of bell-style.
  1103. */
  1104. void
  1105. tinyrl_ding(const tinyrl_t *this)
  1106. {
  1107. tinyrl_vt100_ding(this->term);
  1108. }
  1109. /*-------------------------------------------------------- */
  1110. void
  1111. tinyrl_reset_line_state(tinyrl_t *this)
  1112. {
  1113. /* start from scratch */
  1114. lub_string_free(this->last_buffer);
  1115. this->last_buffer = NULL;
  1116. tinyrl_redisplay(this);
  1117. }
  1118. /*-------------------------------------------------------- */
  1119. void
  1120. tinyrl_replace_line(tinyrl_t *this,
  1121. const char *text,
  1122. int clear_undo)
  1123. {
  1124. size_t new_len = strlen(text);
  1125. /* ignored for now */
  1126. clear_undo = clear_undo;
  1127. /* ensure there is sufficient space */
  1128. if (BOOL_TRUE == tinyrl_extend_line_buffer(this,new_len))
  1129. {
  1130. /* overwrite the current contents of the buffer */
  1131. strcpy(this->buffer,text);
  1132. /* set the insert point and end point */
  1133. this->point = this->end = new_len;
  1134. }
  1135. tinyrl_redisplay(this);
  1136. }
  1137. /*-------------------------------------------------------- */
  1138. static tinyrl_match_e
  1139. tinyrl_do_complete(tinyrl_t *this,
  1140. bool_t with_extensions)
  1141. {
  1142. tinyrl_match_e result = TINYRL_NO_MATCH;
  1143. char **matches = NULL;
  1144. unsigned start,end;
  1145. bool_t completion = BOOL_FALSE;
  1146. bool_t prefix = BOOL_FALSE;
  1147. /* find the start and end of the current word */
  1148. start = end = this->point;
  1149. while(start && !isspace(this->line[start-1]))
  1150. {
  1151. start--;
  1152. }
  1153. if(this->attempted_completion_function)
  1154. {
  1155. this->completion_over = BOOL_FALSE;
  1156. this->completion_error_over = BOOL_FALSE;
  1157. /* try and complete the current line buffer */
  1158. matches = this->attempted_completion_function(this,
  1159. this->line,
  1160. start,
  1161. end);
  1162. }
  1163. if((NULL == matches)
  1164. && (BOOL_FALSE == this->completion_over))
  1165. {
  1166. /* insert default completion call here... */
  1167. }
  1168. if(matches)
  1169. {
  1170. /* identify and insert a common prefix if there is one */
  1171. if(0 != strncmp(matches[0],&this->line[start],strlen(matches[0])))
  1172. {
  1173. /*
  1174. * delete the original text not including
  1175. * the current insertion point character
  1176. */
  1177. if(this->end != end)
  1178. {
  1179. end--;
  1180. }
  1181. tinyrl_delete_text(this,start,end);
  1182. if (BOOL_FALSE == tinyrl_insert_text(this,matches[0]))
  1183. {
  1184. return TINYRL_NO_MATCH;
  1185. }
  1186. completion = BOOL_TRUE;
  1187. }
  1188. if(0 == lub_string_nocasecmp(matches[0],matches[1]))
  1189. {
  1190. /* this is just a prefix string */
  1191. prefix = BOOL_TRUE;
  1192. }
  1193. /* is there more than one completion? */
  1194. if(matches[2] != NULL)
  1195. {
  1196. char **tmp = matches;
  1197. unsigned max,len;
  1198. max = len = 0;
  1199. while(*tmp)
  1200. {
  1201. size_t size = strlen(*tmp++);
  1202. len++;
  1203. if(size > max)
  1204. {
  1205. max = size;
  1206. }
  1207. }
  1208. if(BOOL_TRUE == completion)
  1209. {
  1210. result = TINYRL_COMPLETED_AMBIGUOUS;
  1211. }
  1212. else if(BOOL_TRUE == prefix)
  1213. {
  1214. result = TINYRL_MATCH_WITH_EXTENSIONS;
  1215. }
  1216. else
  1217. {
  1218. result = TINYRL_AMBIGUOUS;
  1219. }
  1220. if((BOOL_TRUE == with_extensions)
  1221. || (BOOL_FALSE == prefix))
  1222. {
  1223. /* Either we always want to show extensions or
  1224. * we haven't been able to complete the current line
  1225. * and there is just a prefix, so let the user see the options
  1226. */
  1227. tinyrl_crlf(this);
  1228. tinyrl_display_matches(this,matches,len,max);
  1229. tinyrl_reset_line_state(this);
  1230. }
  1231. }
  1232. else
  1233. {
  1234. result = completion ? TINYRL_COMPLETED_MATCH : TINYRL_MATCH;
  1235. }
  1236. /* free the memory */
  1237. tinyrl_delete_matches(matches);
  1238. /* redisplay the line */
  1239. tinyrl_redisplay(this);
  1240. }
  1241. return result;
  1242. }
  1243. /*-------------------------------------------------------- */
  1244. tinyrl_match_e
  1245. tinyrl_complete_with_extensions(tinyrl_t *this)
  1246. {
  1247. return tinyrl_do_complete(this,BOOL_TRUE);
  1248. }
  1249. /*-------------------------------------------------------- */
  1250. tinyrl_match_e
  1251. tinyrl_complete(tinyrl_t *this)
  1252. {
  1253. return tinyrl_do_complete(this,BOOL_FALSE);
  1254. }
  1255. /*-------------------------------------------------------- */
  1256. void *
  1257. tinyrl__get_context(const tinyrl_t *this)
  1258. {
  1259. return this->context;
  1260. }
  1261. /*--------------------------------------------------------- */
  1262. const char *
  1263. tinyrl__get_line(const tinyrl_t *this)
  1264. {
  1265. return this->line;
  1266. }
  1267. /*--------------------------------------------------------- */
  1268. tinyrl_history_t *
  1269. tinyrl__get_history(const tinyrl_t *this)
  1270. {
  1271. return this->history;
  1272. }
  1273. /*--------------------------------------------------------- */
  1274. void
  1275. tinyrl_completion_over(tinyrl_t *this)
  1276. {
  1277. this->completion_over = BOOL_TRUE;
  1278. }
  1279. /*--------------------------------------------------------- */
  1280. void
  1281. tinyrl_completion_error_over(tinyrl_t *this)
  1282. {
  1283. this->completion_error_over = BOOL_TRUE;
  1284. }
  1285. /*--------------------------------------------------------- */
  1286. bool_t
  1287. tinyrl_is_completion_error_over(const tinyrl_t *this)
  1288. {
  1289. return this->completion_error_over;
  1290. }
  1291. /*--------------------------------------------------------- */
  1292. void
  1293. tinyrl_done(tinyrl_t *this)
  1294. {
  1295. this->done = BOOL_TRUE;
  1296. }
  1297. /*--------------------------------------------------------- */
  1298. void
  1299. tinyrl_enable_echo(tinyrl_t *this)
  1300. {
  1301. this->echo_enabled = BOOL_TRUE;
  1302. }
  1303. /*--------------------------------------------------------- */
  1304. void
  1305. tinyrl_disable_echo(tinyrl_t *this,
  1306. char echo_char)
  1307. {
  1308. this->echo_enabled = BOOL_FALSE;
  1309. this->echo_char = echo_char;
  1310. }
  1311. /*--------------------------------------------------------- */
  1312. void
  1313. tinyrl__set_istream(tinyrl_t *this,
  1314. FILE *istream)
  1315. {
  1316. tinyrl_vt100__set_istream(this->term,istream);
  1317. this->isatty = isatty(fileno(istream)) ? BOOL_TRUE : BOOL_FALSE;
  1318. }
  1319. /*-------------------------------------------------------- */
  1320. bool_t
  1321. tinyrl__get_isatty(const tinyrl_t *this)
  1322. {
  1323. return this->isatty;
  1324. }
  1325. /*-------------------------------------------------------- */
  1326. FILE *
  1327. tinyrl__get_istream(const tinyrl_t *this)
  1328. {
  1329. return tinyrl_vt100__get_istream(this->term);
  1330. }
  1331. /*-------------------------------------------------------- */
  1332. FILE *
  1333. tinyrl__get_ostream(const tinyrl_t *this)
  1334. {
  1335. return tinyrl_vt100__get_ostream(this->term);
  1336. }
  1337. /*-------------------------------------------------------- */
  1338. const char *
  1339. tinyrl__get_prompt(const tinyrl_t *this)
  1340. {
  1341. return this->prompt;
  1342. }
  1343. /*-------------------------------------------------------- */
  1344. bool_t
  1345. tinyrl_is_quoting(const tinyrl_t *this)
  1346. {
  1347. bool_t result = BOOL_FALSE;
  1348. /* count the quotes upto the current insertion point */
  1349. unsigned i = 0;
  1350. while(i < this->point)
  1351. {
  1352. if(this->line[i++] == '"')
  1353. {
  1354. result = result ? BOOL_FALSE : BOOL_TRUE;
  1355. }
  1356. }
  1357. return result;
  1358. }
  1359. /*--------------------------------------------------------- */
  1360. void
  1361. tinyrl_limit_line_length(tinyrl_t *this, unsigned length)
  1362. {
  1363. this->max_line_length = length;
  1364. }
  1365. /*--------------------------------------------------------- */