| blob | abdc7d96679f67f967386bb13527b7b2f8e75f15 |
1 *** glibc-2.5/./locale/programs/ld-collate.c- 2006-09-21 05:57:30.000000000 +0200
2 --- glibc-2.5/./locale/programs/ld-collate.c 2010-06-01 10:00:50.000000000 +0200
3 ***************
4 *** 1934,1945 ****
5 return retval | ((elem->section->ruleidx & 0x7f) << 24);
6 }
9 void
10 collate_output (struct localedef_t *locale, const struct charmap_t *charmap,
11 const char *output_path)
12 {
13 - struct locale_collate_t *collate = locale->categories[LC_COLLATE].collate;
14 const size_t nelems = _NL_ITEM_INDEX (_NL_NUM_LC_COLLATE);
15 struct iovec iov[2 + nelems];
16 struct locale_file data;
17 --- 1934,2066 ----
18 return retval | ((elem->section->ruleidx & 0x7f) << 24);
19 }
21 + /* If localedef is every threaded, these would need to be __thread var. */
22 + struct obstack weightpool;
23 + struct obstack extrapool;
24 + struct obstack indirectpool;
25 + struct collidx_table tablewc;
26 + struct locale_collate_t *collate;
27 +
28 + static void
29 + add_to_tablewc (uint32_t ch, struct element_t *runp)
30 + {
31 + if (runp->wcnext == NULL && runp->nwcs == 1)
32 + {
33 + int32_t weigthidx = output_weightwc (&weightpool, collate, runp);
34 + collidx_table_add (&tablewc, ch, weigthidx);
35 + }
36 + else
37 + {
38 + /* As for the singlebyte table, we recognize sequences and
39 + compress them. */
40 + struct element_t *lastp;
41 +
42 + collidx_table_add (&tablewc, ch,
43 + -(obstack_object_size (&extrapool) / sizeof (uint32_t)));
44 +
45 + do
46 + {
47 + /* Store the current index in the weight table. We know that
48 + the current position in the `extrapool' is aligned on a
49 + 32-bit address. */
50 + int32_t weightidx;
51 + int added;
52 +
53 + /* Find out wether this is a single entry or we have more than
54 + one consecutive entry. */
55 + if (runp->wcnext != NULL
56 + && runp->nwcs == runp->wcnext->nwcs
57 + && wmemcmp ((wchar_t *) runp->wcs,
58 + (wchar_t *)runp->wcnext->wcs,
59 + runp->nwcs - 1) == 0
60 + && (runp->wcs[runp->nwcs - 1]
61 + == runp->wcnext->wcs[runp->nwcs - 1] + 1))
62 + {
63 + int i;
64 + struct element_t *series_startp = runp;
65 + struct element_t *curp;
66 +
67 + /* Now add first the initial byte sequence. */
68 + added = (1 + 1 + 2 * (runp->nwcs - 1)) * sizeof (int32_t);
69 + if (sizeof (int32_t) == sizeof (int))
70 + obstack_make_room (&extrapool, added);
71 +
72 + /* More than one consecutive entry. We mark this by having
73 + a negative index into the indirect table. */
74 + obstack_int32_grow_fast (&extrapool,
75 + -(obstack_object_size (&indirectpool)
76 + / sizeof (int32_t)));
77 + obstack_int32_grow_fast (&extrapool, runp->nwcs - 1);
78 +
79 + do
80 + runp = runp->wcnext;
81 + while (runp->wcnext != NULL
82 + && runp->nwcs == runp->wcnext->nwcs
83 + && wmemcmp ((wchar_t *) runp->wcs,
84 + (wchar_t *)runp->wcnext->wcs,
85 + runp->nwcs - 1) == 0
86 + && (runp->wcs[runp->nwcs - 1]
87 + == runp->wcnext->wcs[runp->nwcs - 1] + 1));
88 +
89 + /* Now walk backward from here to the beginning. */
90 + curp = runp;
91 +
92 + for (i = 1; i < runp->nwcs; ++i)
93 + obstack_int32_grow_fast (&extrapool, curp->wcs[i]);
94 +
95 + /* Now find the end of the consecutive sequence and
96 + add all the indeces in the indirect pool. */
97 + do
98 + {
99 + weightidx = output_weightwc (&weightpool, collate,
100 + curp);
101 + obstack_int32_grow (&indirectpool, weightidx);
102 +
103 + curp = curp->wclast;
104 + }
105 + while (curp != series_startp);
106 +
107 + /* Add the final weight. */
108 + weightidx = output_weightwc (&weightpool, collate, curp);
109 + obstack_int32_grow (&indirectpool, weightidx);
110 +
111 + /* And add the end byte sequence. Without length this
112 + time. */
113 + for (i = 1; i < curp->nwcs; ++i)
114 + obstack_int32_grow (&extrapool, curp->wcs[i]);
115 + }
116 + else
117 + {
118 + /* A single entry. Simply add the index and the length and
119 + string (except for the first character which is already
120 + tested for). */
121 + int i;
122 +
123 + /* Output the weight info. */
124 + weightidx = output_weightwc (&weightpool, collate, runp);
125 +
126 + added = (1 + 1 + runp->nwcs - 1) * sizeof (int32_t);
127 + if (sizeof (int) == sizeof (int32_t))
128 + obstack_make_room (&extrapool, added);
129 +
130 + obstack_int32_grow_fast (&extrapool, weightidx);
131 + obstack_int32_grow_fast (&extrapool, runp->nwcs - 1);
132 + for (i = 1; i < runp->nwcs; ++i)
133 + obstack_int32_grow_fast (&extrapool, runp->wcs[i]);
134 + }
135 +
136 + /* Next entry. */
137 + lastp = runp;
138 + runp = runp->wcnext;
139 + }
140 + while (runp != NULL);
141 + }
142 + }
144 void
145 collate_output (struct localedef_t *locale, const struct charmap_t *charmap,
146 const char *output_path)
147 {
148 const size_t nelems = _NL_ITEM_INDEX (_NL_NUM_LC_COLLATE);
149 struct iovec iov[2 + nelems];
150 struct locale_file data;
151 ***************
152 *** 1947,1962 ****
153 size_t cnt;
154 size_t ch;
155 int32_t tablemb[256];
156 - struct obstack weightpool;
157 - struct obstack extrapool;
158 - struct obstack indirectpool;
159 struct section_list *sect;
160 - struct collidx_table tablewc;
161 uint32_t elem_size;
162 uint32_t *elem_table;
163 int i;
164 struct element_t *runp;
166 data.magic = LIMAGIC (LC_COLLATE);
167 data.n = nelems;
168 iov[0].iov_base = (void *) &data;
169 --- 2068,2080 ----
170 size_t cnt;
171 size_t ch;
172 int32_t tablemb[256];
173 struct section_list *sect;
174 uint32_t elem_size;
175 uint32_t *elem_table;
176 int i;
177 struct element_t *runp;
179 + collate = locale->categories[LC_COLLATE].collate;
180 data.magic = LIMAGIC (LC_COLLATE);
181 data.n = nelems;
182 iov[0].iov_base = (void *) &data;
183 ***************
184 *** 2292,2414 ****
185 the table. In case we have more than one sequence starting with
186 the same byte we have to use extra indirection. */
187 {
188 - auto void add_to_tablewc (uint32_t ch, struct element_t *runp);
189 -
190 - void add_to_tablewc (uint32_t ch, struct element_t *runp)
191 - {
192 - if (runp->wcnext == NULL && runp->nwcs == 1)
193 - {
194 - int32_t weigthidx = output_weightwc (&weightpool, collate, runp);
195 - collidx_table_add (&tablewc, ch, weigthidx);
196 - }
197 - else
198 - {
199 - /* As for the singlebyte table, we recognize sequences and
200 - compress them. */
201 - struct element_t *lastp;
202 -
203 - collidx_table_add (&tablewc, ch,
204 - -(obstack_object_size (&extrapool) / sizeof (uint32_t)));
205 -
206 - do
207 - {
208 - /* Store the current index in the weight table. We know that
209 - the current position in the `extrapool' is aligned on a
210 - 32-bit address. */
211 - int32_t weightidx;
212 - int added;
213 -
214 - /* Find out wether this is a single entry or we have more than
215 - one consecutive entry. */
216 - if (runp->wcnext != NULL
217 - && runp->nwcs == runp->wcnext->nwcs
218 - && wmemcmp ((wchar_t *) runp->wcs,
219 - (wchar_t *)runp->wcnext->wcs,
220 - runp->nwcs - 1) == 0
221 - && (runp->wcs[runp->nwcs - 1]
222 - == runp->wcnext->wcs[runp->nwcs - 1] + 1))
223 - {
224 - int i;
225 - struct element_t *series_startp = runp;
226 - struct element_t *curp;
227 -
228 - /* Now add first the initial byte sequence. */
229 - added = (1 + 1 + 2 * (runp->nwcs - 1)) * sizeof (int32_t);
230 - if (sizeof (int32_t) == sizeof (int))
231 - obstack_make_room (&extrapool, added);
232 -
233 - /* More than one consecutive entry. We mark this by having
234 - a negative index into the indirect table. */
235 - obstack_int32_grow_fast (&extrapool,
236 - -(obstack_object_size (&indirectpool)
237 - / sizeof (int32_t)));
238 - obstack_int32_grow_fast (&extrapool, runp->nwcs - 1);
239 -
240 - do
241 - runp = runp->wcnext;
242 - while (runp->wcnext != NULL
243 - && runp->nwcs == runp->wcnext->nwcs
244 - && wmemcmp ((wchar_t *) runp->wcs,
245 - (wchar_t *)runp->wcnext->wcs,
246 - runp->nwcs - 1) == 0
247 - && (runp->wcs[runp->nwcs - 1]
248 - == runp->wcnext->wcs[runp->nwcs - 1] + 1));
249 -
250 - /* Now walk backward from here to the beginning. */
251 - curp = runp;
252 -
253 - for (i = 1; i < runp->nwcs; ++i)
254 - obstack_int32_grow_fast (&extrapool, curp->wcs[i]);
255 -
256 - /* Now find the end of the consecutive sequence and
257 - add all the indeces in the indirect pool. */
258 - do
259 - {
260 - weightidx = output_weightwc (&weightpool, collate,
261 - curp);
262 - obstack_int32_grow (&indirectpool, weightidx);
263 -
264 - curp = curp->wclast;
265 - }
266 - while (curp != series_startp);
267 -
268 - /* Add the final weight. */
269 - weightidx = output_weightwc (&weightpool, collate, curp);
270 - obstack_int32_grow (&indirectpool, weightidx);
271 -
272 - /* And add the end byte sequence. Without length this
273 - time. */
274 - for (i = 1; i < curp->nwcs; ++i)
275 - obstack_int32_grow (&extrapool, curp->wcs[i]);
276 - }
277 - else
278 - {
279 - /* A single entry. Simply add the index and the length and
280 - string (except for the first character which is already
281 - tested for). */
282 - int i;
283 -
284 - /* Output the weight info. */
285 - weightidx = output_weightwc (&weightpool, collate, runp);
286 -
287 - added = (1 + 1 + runp->nwcs - 1) * sizeof (int32_t);
288 - if (sizeof (int) == sizeof (int32_t))
289 - obstack_make_room (&extrapool, added);
290 -
291 - obstack_int32_grow_fast (&extrapool, weightidx);
292 - obstack_int32_grow_fast (&extrapool, runp->nwcs - 1);
293 - for (i = 1; i < runp->nwcs; ++i)
294 - obstack_int32_grow_fast (&extrapool, runp->wcs[i]);
295 - }
296 -
297 - /* Next entry. */
298 - lastp = runp;
299 - runp = runp->wcnext;
300 - }
301 - while (runp != NULL);
302 - }
303 - }
304 -
305 tablewc.p = 6;
306 tablewc.q = 10;
307 collidx_table_init (&tablewc);
308 --- 2410,2415 ----