readline库实现命令行自动补全-凯发app官方网站

凯发app官方网站-凯发k8官网下载客户端中心 | | 凯发app官方网站-凯发k8官网下载客户端中心

苦海澜石

凯发app官方网站首页　| 　博文目录　| 　关于我

khls27

  • 博客访问： 752961
  • 博文数量： 144
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 1150
  • 用 户 组： 普通用户
  • 注册时间： 2014-03-17 14:32
个人简介

小公司研发总监，既当司令也当兵！

文章分类

全部博文（144）

推荐博文
相关博文
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
readline库实现命令行自动补全

分类： linux

2015-05-25 01:46:59

readline库实现命令行自动补全

   linux下应用程序可能需要交互式输入命令，但普通的标准io进行命令输入显得有些呆板，人性化不足。本文讲述使用libreadline库，实现类似sh的交换终端：支持命令自动补全，支持历史命令等。

    part1: readline安装
    （1） 下载readline源码：
    （2） 解压后， 在源码目录依次执行 ./configure, make, sudo make install 完成安装

    part2：readline使用举例
点击(此处)折叠或打开
  1. #include <stdlib.h>
  2. #include <stdio.h> //注意，readline.h中可能需要调用标准io库的内容，所以stdio.h必须在readline.h之前被包含
  3. #include <readline/readline.h>
  4. #include <readline/history.h>


  7. /*
  8. * 真正的命令执行函数
  9. * 测试时，被定义为桩函数了
  10. */
  11. int com_list(char *para)
  12. {
  13.     printf("do com_list:%s\n", para);
  14.     return 0;
  15. }
  16.     
  17. int com_view(char *para)
  18. {
  19.     printf("do com_view:%s\n", para);
  20.     return 0;
  21. }

  23. int com_rename(char *para)
  24. {
  25.     printf("do com_rename:%s\n", para);
  26.     return 0;
  27. }
  28. int com_stat(char *para)
  29. {
  30.     printf("do com_stat:%s\n", para);
  31.     return 0;
  32. }

  34. int com_pwd(char *para)
  35. {
  36.     printf("do com_pwd:%s\n", para);
  37.     return 0;
  38. }
  39. int com_delete(char *para)
  40. {
  41.     printf("do com_delete:%s\n", para);
  42.     return 0;
  43. }
  44. int com_help(char *para)
  45. {
  46.     printf("do com_help:%s\n", para);
  47.     return 0;
  48. }

  50. int com_cd(char *para)
  51. {
  52.     printf("do com_cd:%s\n", para);
  53.     return 0;
  54. }
  55. int com_quit(char *para)
  56. {
  57.     printf("do com_quit:%s\n", para);
  58.     exit(0);
  59. }


  62. /*
  63. * a structure which contains information on the commands this program
  64. * can understand.
  65. */
  66. typedef struct {
  67.     char *name;            /* user printable name of the function. */
  68.     rl_icpfunc_t *func;        /* function to call to do the job. */
  69.     char *doc;            /* documentation for this function. */
  70. } command;

  72. command commands[] = {
  73.   { "cd", com_cd, "change to directory dir" },
  74.   { "delete", com_delete, "delete file" },
  75.   { "help", com_help, "display this text" },
  76.   { "?", com_help, "synonym for `help'" },
  77.   { "list", com_list, "list files in dir" },
  78.   { "ls", com_list, "synonym for `list'" },
  79.   { "pwd", com_pwd, "print the current working directory" },
  80.   { "quit", com_quit, "quit using fileman" },
  81.   { "rename", com_rename, "rename file to newname" },
  82.   { "stat", com_stat, "print out statistics on file" },
  83.   { "view", com_view, "view the contents of file" },
  84.   { (char *)null, (rl_icpfunc_t *)null, (char *)null }
  85. };


  88. char* dupstr(char *s)
  89. {
  90.   char *r;

  92.   r = malloc (strlen (s) 1);
  93.   strcpy(r, s);
  94.   return (r);
  95. }

  97. // clear up white spaces
  98. char* stripwhite (char *string)
  99. {
  100.     register char *s, *t;
  101.     
  102.     for (s = string; whitespace (*s); s)
  103.         ;
  104.     
  105.     if (*s == 0)
  106.         return (s);

  108.     t = s strlen (s) - 1;
  109.     while (t > s && whitespace (*t))
  110.         t--;

  112.     *t = '\0';

  114.     return s;
  115. }


  118. /*
  119. * look up name as the name of a command, and return a pointer to that
  120. * command. return a null pointer if name isn't a command name.
  121. */
  122. command *find_command (char *name)
  123. {
  124.     register int i;
  125.     
  126.     for (i = 0; commands[i].name; i)
  127.         if (strcmp (name, commands[i].name) == 0)
  128.             return (&commands[i]);

  130.     return ((command *)null);
  131. }

  133. /* execute a command line. */
  134. int execute_line (char *line)
  135. {
  136.     register int i;
  137.     command *command;
  138.     char *word;

  140.     /* isolate the command word. */
  141.     i = 0;
  142.     while (line[i] && whitespace (line[i]))
  143.         i;
  144.     word = line i;

  146.     while (line[i] && !whitespace (line[i]))
  147.         i;

  149.     if (line[i])
  150.         line[i] = '\0';

  152.     command = find_command (word);

  154.     if (!command)
  155.     {
  156.         fprintf (stderr, "%s: no such command for fileman.\n", word);
  157.         return (-1);
  158.     }

  160.     /* get argument to command, if any. */
  161.     while (whitespace (line[i]))
  162.         i;

  164.     word = line i;

  166.     /* call the function. */
  167.     return ((*(command->func)) (word));
  168. }

  170. /*
  171. * generator function for command completion. state lets us know whether
  172. * to start from scratch; without any state (i.e. state == 0), then we
  173. * start at the top of the list.
  174. */
  175. char* command_generator (const char *text, int state)
  176. {
  177.     static int list_index, len;
  178.     char *name;

  180.     /*
  181.     * if this is a new word to complete, initialize now. this includes
  182.     * saving the length of text for efficiency, and initializing the index
  183.     * variable to 0.
  184.     */
  185.     if (!state)
  186.     {
  187.          list_index = 0;
  188.         len = strlen (text);
  189.     }

  191.     /* return the next name which partially matches from the command list. */
  192.     while (name = commands[list_index].name)
  193.     {
  194.          list_index;
  195.     
  196.          if (strncmp (name, text, len) == 0)
  197.              return (dupstr(name));
  198.     }

  200.     /* if no names matched, then return null. */
  201.     return ((char *)null);
  202. }

  204. /*
  205. * attempt to complete on the contents of text. start and end bound the
  206. * region of rl_line_buffer that contains the word to complete. text is
  207. * the word to complete. we can use the entire contents of rl_line_buffer
  208. * in case we want to do some simple parsing. return the array of matches,
  209. * or null if there aren't any.
  210. */
  211. char** fileman_completion (const char *text, int start, int end)
  212. {
  213.     char **matches;

  215.     matches = (char **)null;

  217.     /*
  218.     * if this word is at the start of the line, then it is a command
  219.     * to complete. otherwise it is the name of a file in the current
  220.     * directory.
  221.     */
  222.     if (start == 0)
  223.         matches = rl_completion_matches (text, command_generator);

  225.     return (matches);
  226. }


  229. /*
  230. * tell the gnu readline library how to complete. we want to try to complete
  231. * on command names if this is the first word in the line, or on filenames
  232. * if not.
  233. */
  234. void initialize_readline ()
  235. {
  236.     /* allow conditional parsing of the ~/.inputrc file. */
  237.     rl_readline_name = ">";

  239.     /* tell the completer that we want a crack first. */
  240.     rl_attempted_completion_function = fileman_completion;
  241. }




  246. int main (int argc, char **argv)
  247. {
  248.     char *line, *s;
  249.     
  250.     initialize_readline();    /* bind our completer. */


  253.     /* loop reading and executing lines until the user quits. */
  254.     for ( ; ;)
  255.     {
  256.         line = readline (">: ");

  258.         if (!line)
  259.             break;

  261.         /*
  262.         * remove leading and trailing whitespace from the line.
  263.         * then, if there is anything left, add it to the history list
  264.         * and execute it.
  265.         */
  266.          s = stripwhite (line);
  267.          if (*s)
  268.          {
  269.              add_history(s);
  270.              execute_line(s);
  271.          }

  273.         free(line);
  274.     }
  275.     exit(0);
  276. }
    注意，编译的时候需要连接readline库，例如：gcc  -o  irlt  ireadlinetest.c  -lreadline   

    part3： readline下的io复用
    

   但是如果我们有多个 io 要处理，比如既要从一个网络 io 中读数据，又要从标准输入中读取命令，上面的方法就不合适了。为了解决这个问题，我们需要自己用 select 函数监控这两个 io，当它们可读的时候通知这两个模块中的输入函数。形象地说，就是把数据“喂给”这两个模块。这样的模式需要 readline 提供“被动喂给”的工作方式。这种工作方式在 readline 中已有实现。首先，我们需要往 readline 注册回调函数，当 readline 读取到一行后，这个回调函数将被调用: 

  rl_callback_handler_install ("prompt> ", handle_command);

接下去，在主事件循环中，我们需要调用 rl_callback_read_char() 通知 readline 去读取一个字符。

下面给一个例子：

点击(此处)折叠或打开

  1. static void handle_command (char *line)
  2. {
  3.     ...
  4. }
  5.  
  6. int
  7. main (int argc, char **argv)
  8. {
  9.     int netfd
  10.     fd_set allfd;
  11.     int maxfd;
  12.  
  13.     netfd = connect_to_server ();
  14.  
  15.  
  16.     fd_zero (&allfd);
  17.     fd_set (fileno(stdin), &allfd);
  18.     fd_set (netfd, &allfd);
  19.     maxfd = netfd;
  20.  
  21.     rl_callback_handler_install ("ccnet> ", handle_command);
  22.  
  23.     while (1) {
  24.         fd_set rfds;
  25.         int retval;
  26.  
  27.         rfds = allfd;
  28.  
  29.         retval = select (maxfd 1, &rfds, null, null, null);
  30.         if (retval < 0)
  31.             perror ("select");
  32.  
  33.         if (fd_isset(0, &rfds))
  34.             rl_callback_read_char();
  35.  
  36.         if (fd_isset(netfd, &rfds))
  37.             read_from_network (netfd);
  38.     }
  39. }

关于readline更多的使用请自行阅读readline的man文件。




阅读(7422) | 评论(0) | 转发(0) |
0

上一篇：linux网桥实现分析

下一篇：linux 应用程序参数解析（getopt/getopt_long）

给主人留下些什么吧！~~
| | | | |

凯发app官方网站 copyright 2001-2010 chinaunix.net all rights reserved 北京皓辰网域网络信息技术有限公司. 凯发k8官网下载客户端中心的版权所有

感谢所有关心和支持过chinaunix的朋友们
")); function link(t){ var href= $(t).attr('href'); href ="?url=" encodeuricomponent(location.href); $(t).attr('href',href); //setcookie("returnouturl", location.href, 60, "/"); }
网站地图