← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to trampoline/norm.c

  • Committer: drtomc
  • Date: 2008-01-30 20:53:22 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:336
Rename main.c to test.c. Should have been that in the first place - I was tired when I did it last night.

Show diffs side-by-side

added added

removed removed

Lines of Context:
trampoline/norm.c
 
1
#include <assert.h>
 
2
#include <string.h>
 
3
#include <stdlib.h>
 
4
#include <stdio.h>
 
5
#include <unistd.h>
 
6
#include "norm.h"
 
7
 
 
8
#define SKP()               \
 
9
    do {                    \
 
10
        s++;                \
 
11
    } while (0)
 
12
 
 
13
#define CPY()               \
 
14
    do {                    \
 
15
        *d++ = *s++;        \
 
16
    } while (0)
 
17
 
 
18
#define MRK()               \
 
19
    do {                    \
 
20
        PUSH();             \
 
21
    } while (0)
 
22
 
 
23
#define BKP()               \
 
24
    do {                    \
 
25
        POP();              \
 
26
    } while (0)
 
27
 
 
28
#define BKP2()              \
 
29
    do {                    \
 
30
        POP();              \
 
31
        POP();              \
 
32
    } while (0)
 
33
 
 
34
#define PUSH()              \
 
35
    do {                    \
 
36
        stk[top++] = d;     \
 
37
    } while (0)
 
38
 
 
39
#define POP()               \
 
40
    do {                    \
 
41
        if (top == 0)       \
 
42
        {                   \
 
43
            dest[0] = '\0'; \
 
44
            return -1;      \
 
45
        }                   \
 
46
        d = stk[--top];     \
 
47
    } while (0)
 
48
 
 
49
/*
 
50
 * Normalize the unix pathname in src eliminating .. sequences
 
51
 * to yield an absolute path. Returns 0 on success, and -1 on
 
52
 * error.
 
53
 */
 
54
int norm(char* dest, int len, const char* src)
 
55
{
 
56
    const char* s = src;
 
57
    char* d = dest;
 
58
    char* stk[256];
 
59
    int top = 0;
 
60
    enum { L0, L1, L2, L3, L4 } state = L0;
 
61
    assert(strlen(src) <= len);
 
62
 
 
63
    while (*s)
 
64
    {
 
65
        char c = *s;
 
66
        enum { slash, dot, other } cls;
 
67
        switch (c)
 
68
        {
 
69
            case '/':
 
70
            {
 
71
                cls = slash;
 
72
                break;
 
73
            }
 
74
            case '.':
 
75
            {
 
76
                cls = dot;
 
77
                break;
 
78
            }
 
79
            default:
 
80
            {
 
81
                cls = other;
 
82
            }
 
83
        }
 
84
        switch (state)
 
85
        {
 
86
            case L0:
 
87
            {
 
88
                switch (cls)
 
89
                {
 
90
                    case slash:
 
91
                    {
 
92
                        CPY();
 
93
                        state = L1;
 
94
                        break;
 
95
                    }
 
96
                    case dot:
 
97
                    case other:
 
98
                    {
 
99
                        dest[0] = '\0';
 
100
                        return -1;
 
101
                    }
 
102
                }
 
103
                break;
 
104
            }
 
105
            case L1:
 
106
            {
 
107
                switch (cls)
 
108
                {
 
109
                    case slash:
 
110
                    {
 
111
                        SKP();
 
112
                        break;
 
113
                    }
 
114
                    case dot:
 
115
                    {
 
116
                        MRK();
 
117
                        CPY();
 
118
                        state = L2;
 
119
                        break;
 
120
                    }
 
121
                    case other:
 
122
                    {
 
123
                        MRK();
 
124
                        CPY();
 
125
                        state = L4;
 
126
                        break;
 
127
                    }
 
128
                }
 
129
                break;
 
130
            }
 
131
            case L2:
 
132
            {
 
133
                switch (cls)
 
134
                {
 
135
                    case slash:
 
136
                    {
 
137
                        BKP();
 
138
                        state = L1;
 
139
                        break;
 
140
                    }
 
141
                    case dot:
 
142
                    {
 
143
                        CPY();
 
144
                        state = L3;
 
145
                        break;
 
146
                    }
 
147
                    case other:
 
148
                    {
 
149
                        CPY();
 
150
                        state = L4;
 
151
                        break;
 
152
                    }
 
153
                }
 
154
                break;
 
155
            }
 
156
            case L3:
 
157
            {
 
158
                switch (cls)
 
159
                {
 
160
                    case slash:
 
161
                    {
 
162
                        BKP2();
 
163
                        state = L1;
 
164
                        break;
 
165
                    }
 
166
                    case dot:
 
167
                    case other:
 
168
                    {
 
169
                        CPY();
 
170
                        state = L4;
 
171
                        break;
 
172
                    }
 
173
                }
 
174
                break;
 
175
            }
 
176
            case L4:
 
177
            {
 
178
                switch (cls)
 
179
                {
 
180
                    case slash:
 
181
                    {
 
182
                        CPY();
 
183
                        state = L1;
 
184
                        break;
 
185
                    }
 
186
                    case dot:
 
187
                    case other:
 
188
                    {
 
189
                        CPY();
 
190
                        break;
 
191
                    }
 
192
                }
 
193
                break;
 
194
            }
 
195
        }
 
196
    }
 
197
    *d = '\0';
 
198
    return 0;
 
199
}