求解释一段简化路径的代码……

lyreopera

看lighttpd中一段简化路径的代码，看得吐血……

我稍微简化了一下，用gdb调，感觉大致明白了意思，但是理不清楚其中具体的逻辑，特别是while循环那一段……有什么好办法啊？

1. #include <assert.h>
   
2. #include <stdio.h>
   
3. 
   
4. /* Remove "/../", "//", "/./" parts from path.
   
5. *
   
6. * /blah/..         gets  /
   
7. * /blah/../foo     gets  /foo
   
8. * /abc/./xyz       gets  /abc/xyz
   
9. * /abc//xyz        gets  /abc/xyz
   
10. *
    
11. * NOTE: src and dest can point to the same buffer, in which case,
    
12. *       the operation is performed in-place.
    
13. */
    
14. int buffer_path_simplify(char *dest, char *src)
    
15. {
    
16.         int toklen;
    
17.         char c, pre1;
    
18.         char *start, *slash, *walk, *out;
    
19.         unsigned short pre;
    
20. 
    
21.         if (src == NULL || dest == NULL)
    
22.                 return -1;
    
23. 
    
24.         walk  = src;
    
25.         start = dest;
    
26.         out   = dest;
    
27.         slash = dest;
    
28. 
    
29.         while (*walk == ' ') {
    
30.                 walk++;
    
31.         }
    
32. 
    
33.         pre1 = *(walk++);
    
34.         c    = *(walk++);
    
35.         pre  = pre1;
    
36.         if (pre1 != '/') {
    
37.                 pre = ('/' << 8) | pre1;
    
38.                 *(out++) = '/';
    
39.         }
    
40.         *(out++) = pre1;
    
41. 
    
42.         if (pre1 == '\0') {
    
43.                 return 0;
    
44.         }
    
45. 
    
46.         while (1) {
    
47.                 if (c == '/' || c == '\0') {
    
48.                         toklen = out - slash;
    
49.                         if (toklen == 3 && pre == (('.' << 8) | '.')) {
    
50.                                 out = slash;
    
51.                                 if (out > start) {
    
52.                                         out--;
    
53.                                         while (out > start && *out != '/') {
    
54.                                                 out--;
    
55.                                         }
    
56.                                 }
    
57. 
    
58.                                 if (c == '\0')
    
59.                                         out++;
    
60.                         } else if (toklen == 1 || pre == (('/' << 8) | '.')) {
    
61.                                 out = slash;
    
62.                                 if (c == '\0')
    
63.                                         out++;
    
64.                         }
    
65. 
    
66.                         slash = out;
    
67.                 }
    
68. 
    
69.                 if (c == '\0')
    
70.                         break;
    
71. 
    
72.                 pre1 = c;
    
73.                 pre  = (pre << 8) | pre1;
    
74.                 c    = *walk;
    
75.                 *out = pre1;
    
76. 
    
77.                 out++;
    
78.                 walk++;
    
79.         }
    
80. 
    
81.         *out = '\0';
    
82. 
    
83.         return 0;
    
84. }
    
85. 
    
86. int main (int argc, char *argv[])
    
87. {
    
88.         char buf[1024] = {0};
    
89.         assert (argc == 2);
    
90. 
    
91.         buffer_path_simplify (buf, argv[1]);
    
92. 
    
93.         printf ("%s\n", buf);
    
94.        
    
95.         return 0;
    
96. }

复制代码

lenky0401

那个是对“/a/b/c/../../b/../”这种做精简
因为“/a/b/c/../../b/../” 就等于“/a/”

然后 它的比较是采用的short类型（变量pre）进行的比较，这样可以一次比较两个字节（如果是按字节比较，则有&&运算符），对代码有一定的简化作用

理清了也好懂

lyreopera

这一点我还是明白的，但是像这种比较复杂的逻辑……

要怎么确定这个循环能正确的结束，得到正确的结果

或者是用循环不变式来验证：

1.循环初始化时是正确的；
2.每一次迭代的结果都是正确的；
3.循环结束时的结果也是正确的。

我得好好琢磨一下

ydfgic

蛮好懂的代码啊
有点bug，就是 36行，所写，就必须要求是以 '/'开头的路径，相对路径就不对了