command 的内容为什么总是空的

thb303663990

int split(struct command_line * command, char cline[ ])
{
        int i;
        int pos = 0;
        cline[strlen(cline) - 1] = '\0';
        //del_blank(pos, cline);
        while(cline[pos] != '\0' && (cline[pos] == ' ' || cline[pos] == '\t'))
        {
               pos++;
        }                                                   //去除空格及制表符
                i = 0;
        while(cline[pos] != '\0'){
                if((command->argv = (char *)malloc(MAX_LENGTH)) == NULL){
                        perror("fail to malloc");
                        return -1;
                        }
                //get_arg(command->argv, pos, cline);
                int i = 0;
        while(cline[pos] != '\0' || cline[pos] != ' ' || cline[pos] != '\t'){
                command->argv[i++] = cline[pos++];//将cline的值传递给command所指的结构体



        } ;
                i++;
        //      del_blank(pos, cline);
                while(cline[pos] != '\0' && (cline[pos] == ' ' || cline[pos] == '\t'))
        {
                pos++;
        }
        command->argv = NULL;
        command->name = command->argv[0];
        return i;

}
}
为什么command'的内容总是空的
如果cline为get 123.c 能把get传给name不

egmkang

gdb a.out
b split
r
然后n,p,你懂得

thb303663990

回复 2# egmkang


  就是这么调试，发现command.name一直为0

tubocurarine

command->argv = NULL;
        command->name = command->argv[0];

这是干什么？没看懂。

cobras

推荐一个命令行解析函数。

1. 
   
2. #include <stddef.h>
   
3. 
   
4. /*                           phrase_command_line
   
5. **
   
6. **                                                 AUTHOR: Cobras Zhang
   
7. **                                                 SITE  : www.cobsoft.com
   
8. **                                                 DATE  : 2011-3
   
9. **
   
10. **    phrase_command_line will take each element seperated by space or quoted
    
11. **    by double quote mark as a single argument item. for example:
    
12. **
    
13. **        test.exe "this is a file.jpg"another_file.jpg"yet a file.jpg" -opt
    
14. **
    
15. **    will be phrased as the following five argument items(not including the
    
16. **    leading index number):
    
17. **
    
18. **        1 test.exe
    
19. **        2 this is a file.jpg
    
20. **        3 another_file.jpg
    
21. **        4 yet a file.jpg
    
22. **        5 -opt
    
23. **
    
24. **    as you see, two elements just seperated by double quote mark will be
    
25. **    taken as two different argument items. that is the mechanism of
    
26. **    phrase_command_line function.
    
27. **
    
28. **    empty argument item is not exist. that is "" will not be taken as a
    
29. **    argument item.
    
30. **
    
31. **    if a element leading by double quote mark and no terminating mark, all
    
32. **    the characters after that leading mark will be taken as a single
    
33. **    argument item.
    
34. **
    
35. **    if o_argv is NULL, phrase_command_line only return the argument count
    
36. **    of command line, else phrase_command_line will modify cmd_line and set
    
37. **    o_argv array to point each argument item.
    
38. **
    
39. **    the return value of phrase_command_line function is the count of
    
40. **    argument items, not including the NULL termiator.
    
41. **
    
42. **    please take carefull that o_argv must be great enough to store all the
    
43. **    pointer array and a NULL terminator, otherwise, the program may be
    
44. **    breaked down. thus, you'd better use phrase_command_line itself to
    
45. **    caculate the proper count of arguments by giving a NULL o_argv and then
    
46. **    allocate the memory of a pointer array with the length of this count
    
47. **    plus one.
    
48. */
    
49. 
    
50. int phrase_command_line(char *cmd_line, char **o_argv)
    
51. {
    
52.         int argc;
    
53.         if (cmd_line != NULL) {
    
54.                 argc = 0;
    
55.                 for (;;) {
    
56.                         switch (*cmd_line) {
    
57.                         case ' ':
    
58.                         case '\t':
    
59.                                 if (o_argv != NULL) {
    
60.                                         *cmd_line = '\0';
    
61.                                 }
    
62.                                 cmd_line++;
    
63.                                 continue;
    
64.                         case '"':
    
65.                                 if (o_argv != NULL) {
    
66.                                         *cmd_line ='\0';
    
67.                                         o_argv[argc] = cmd_line + 1;
    
68.                                 }
    
69.                                 cmd_line++;
    
70.                                 switch (*cmd_line) {
    
71.                                 case '"':
    
72.                                 case '\r':
    
73.                                 case '\n':
    
74.                                 case '\0':
    
75.                                         break;
    
76.                                 default:
    
77.                                         argc++;
    
78.                                         break;
    
79.                                 }
    
80.                                 for (;;) {
    
81.                                         switch (*cmd_line) {
    
82.                                         case '"':
    
83.                                                 if (o_argv != NULL) {
    
84.                                                         *cmd_line = '\0';
    
85.                                                 }
    
86.                                                 cmd_line++;
    
87.                                                 break;
    
88.                                         case '\r':
    
89.                                         case '\n':
    
90.                                         case '\0':
    
91.                                                 if (o_argv != NULL) {
    
92.                                                         *cmd_line = '\0';
    
93.                                                         o_argv[argc] = NULL;
    
94.                                                 }
    
95.                                                 return argc;
    
96.                                         default:
    
97.                                                 cmd_line++;
    
98.                                                 continue;
    
99.                                         }
    
100.                                         break;
     
101.                                 }
     
102.                                 continue;
     
103.                         case '\r':
     
104.                         case '\n':
     
105.                         case '\0':
     
106.                                 if (o_argv != NULL) {
     
107.                                         *cmd_line = '\0';
     
108.                                         o_argv[argc] = NULL;
     
109.                                 }
     
110.                                 return argc;
     
111.                         default:
     
112.                                 if (o_argv != NULL) {
     
113.                                         o_argv[argc] = cmd_line;
     
114.                                 }
     
115.                                 cmd_line++;
     
116.                                 argc++;
     
117.                                 for (;;) {
     
118.                                         switch (*cmd_line) {
     
119.                                         case '"':
     
120.                                                 break;
     
121.                                         case ' ':
     
122.                                         case '\t':
     
123.                                                 if (o_argv != NULL) {
     
124.                                                         *cmd_line = '\0';
     
125.                                                 }
     
126.                                                 cmd_line++;
     
127.                                                 break;
     
128.                                         case '\r':
     
129.                                         case '\n':
     
130.                                         case '\0':
     
131.                                                 if (o_argv != NULL) {
     
132.                                                         *cmd_line = '\0';
     
133.                                                         o_argv[argc] = NULL;
     
134.                                                 }
     
135.                                                 return argc;
     
136.                                         default:
     
137.                                                 cmd_line++;
     
138.                                                 continue;
     
139.                                         }
     
140.                                         break;
     
141.                                 }
     
142.                                 continue;
     
143.                         }
     
144.                 }
     
145.         }
     
146.         return -1;
     
147. }
     
148. 
     
149. #include <stdio.h>
     
150. #include <stdlib.h>
     
151. 
     
152. int main(void)
     
153. {
     
154.         char command_line[1024];
     
155.         int argc;
     
156.         char **argv;
     
157.         int i;
     
158. 
     
159.         printf("COMMAND> ");
     
160.         if (fgets(command_line, sizeof(command_line), stdin) != NULL) {
     
161.                 argc = phrase_command_line(command_line, NULL);
     
162.                 if (argc > 0) {
     
163.                         argv = (char **)malloc(sizeof(char *) * (argc + 1));
     
164.                         if (argv != NULL) {
     
165.                                 phrase_command_line(command_line, argv);
     
166.                                 printf("argv:\n\n");
     
167.                                 for (i = 0; i < argc; i++) {
     
168.                                         printf("  %d: %s\n", i, argv[i]);
     
169.                                 }
     
170.                                 free(argv);
     
171.                                 return 0;
     
172.                         }
     
173.                 }
     
174.         }
     
175.         return -1;
     
176. }
     

复制代码

csern

用getopt和getopt_long吧，接口统一

cobras

用getopt和getopt_long吧，接口统一
csern 发表于 2011-03-11 14:56

    楼主这是要分割命令行为参数呢，不是要分析参数。就是在main之前做的事。crt0?{:3_198:}

csern

回复 7# cobras

刚才没仔细看，不好意思了,貌似是个类似于命令行ftp客户端的东西吧。

1. command->argv = NULL;
   
2. command->name = command->argv[0];

复制代码

这要段错误的吧，lz贴错代码了么,

thb303663990

回复 8# csern


   恩，应该是 command->argv=NULL,系统好像显示不出来

cobras

我分析LZ的struct command_line的结构是不是这样的：

1. 
   
2. struct command_line {
   
3.     char **argv;
   
4.     char *name;
   
5. };
   

复制代码

如果是这样的，哪么你的代码完全错误，不仅功能无法实现，而且还有致命错误。