1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
/* { dg-do run } */
extern void abort (void);
typedef int int32_t __attribute__ ((mode (SI)));
typedef int int64_t __attribute__ ((mode (DI)));
typedef __SIZE_TYPE__ size_t;
struct slice
{
unsigned char *data;
int64_t len;
int64_t cap;
};
void fail (int32_t) __attribute__ ((noinline));
void
fail (int32_t c)
{
if (c != 0)
abort ();
}
struct decode_rune_ret
{
int32_t r;
int64_t width;
};
struct decode_rune_ret decode_rune (struct slice) __attribute__ ((noinline));
struct decode_rune_ret
decode_rune (struct slice s)
{
struct decode_rune_ret dr;
dr.r = s.data[0];
dr.width = 1;
return dr;
}
_Bool is_space (int32_t) __attribute__ ((noinline));
_Bool
is_space (int32_t r)
{
return r == ' ';
}
struct ret
{
int64_t advance;
struct slice token;
};
struct ret scanwords (struct slice, _Bool) __attribute__ ((noinline));
struct ret
scanwords (struct slice data, _Bool ateof)
{
int64_t advance;
struct slice token;
int64_t start = 0;
{
int64_t width;
for (width = 0; start < data.len; start += width)
{
int32_t r = 0;
struct slice s;
if (start > data.cap || start < 0)
fail (3);
s.data = data.data + (size_t) start;
s.len = data.len - start;
s.cap = data.cap - start;
struct decode_rune_ret dr = decode_rune (s);
r = dr.r;
width = dr.width;
if (!is_space (r))
break;
}
}
_Bool tmp = ateof;
if (tmp != 0)
goto L1;
else
goto L2;
L1:
tmp = data.len == 0;
L2:
if (tmp != 0)
goto L11;
else
goto L12;
L11:
{
struct ret r;
advance = 0;
token.data = 0;
token.len = 0;
token.cap = 0;
r.advance = advance;
r.token = token;
return r;
}
L12:;
int64_t width;
int64_t i;
for (width = 0, i = start; i < data.len; i += width)
{
int32_t r;
struct slice s;
if (i > data.cap || i < 0)
fail (3);
s.data = data.data + i;
s.len = data.len - i;
s.cap = data.cap - i;
struct decode_rune_ret dr = decode_rune (s);
r = dr.r;
width = dr.width;
if (is_space (r))
{
if (i < start || i > data.cap || i < 0)
fail (3);
if (start > data.cap || start < 0)
fail (3);
struct ret r;
advance = i + width;
token.data = data.data + (size_t) start;
token.len = i - start;
token.cap = data.cap - start;
r.advance = advance;
r.token = token;
return r;
}
}
{
struct ret r;
advance = 0;
token.data = 0;
token.len = 0;
token.cap = 0;
r.advance = advance;
r.token = token;
return r;
}
}
int
main ()
{
unsigned char buf[1000];
struct slice s;
__builtin_memset (buf, 0, sizeof (buf));
buf[0] = ' ';
buf[1] = 'a';
buf[2] = ' ';
s.data = buf;
s.len = 3;
s.cap = sizeof (buf);
struct ret r;
r = scanwords (s, 1);
if (r.advance != 3 || r.token.data[0] != 'a' || r.token.len != 1)
abort ();
return 0;
}
|
