Debian Codegraph @

gcc/testsuite/gm2/switches/pedantic-params/pass/Strings2.mod

raw
1 (* Copyright (C) 2005, 2006 Free Software Foundation, Inc. *)
2 (* This file is part of GNU Modula-2.
3
4 GNU Modula-2 is free software; you can redistribute it and/or modify it under
5 the terms of the GNU General Public License as published by the Free
6 Software Foundation; either version 2, or (at your option) any later
7 version.
8
9 GNU Modula-2 is distributed in the hope that it will be useful, but WITHOUT ANY
10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 for more details.
13
14 You should have received a copy of the GNU General Public License along
15 with gm2; see the file COPYING. If not, write to the Free Software
16 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *)
17 (* ---------------------------------------------------------------------
18 * This program is copyright (c) 1996 Faculty of Information Technology,
19 * Queensland University of Technology, Brisbane, Australia.
20 * The program may be freely distributed in source or compiled form,
21 * provided this copyright notice remains intact in the sources.
22 * --------------------------------------------------------------------- *)
23
24 (****************************************************************
25 $Log: Strings2.mod,v $
26 Revision 1.3 2006/01/11 00:12:52 gaius
27 added 2006 to all Copyright dates
28
29 Revision 1.2 2005/11/18 21:54:50 gaius
30 fixed Copyright dates and added GPL notices to all files.
31
32 Revision 1.1 2004/10/26 14:40:19 gaius
33 added switch pass and fail tests
34
35 Revision 1.2 2004/10/17 11:46:06 iztok
36 *** empty log message ***
37
38 Revision 1.1.1.1 2004/10/06 05:46:24 iztok
39 Gardens Point Modula-2 ISO libs directory
40
41 Revision 1.1 2003/11/04 21:34:13 iztokk
42 added library sources and some document stuff
43
44 Revision 1.1 1996/09/06 07:51:32 lederman
45 Initial revision
46
47 *)
48
49 IMPLEMENTATION MODULE Strings2;
50 (*
51 * Purpose:
52 * Facilities for manipulating strings
53 *
54 * Log:
55 * 25/08/96 JL Initial Release
56 *
57 * Acknowledgments:
58 * All procedures are substantially based on the existing
59 * GPM module StdStrings
60 *
61 * Notes:
62 * Complies with ISO/IEC 10514-1:1996
63 *
64 *)
65
66 IMPORT ASCII;
67
68
69 PROCEDURE Length (stringVal : ARRAY OF CHAR) : CARDINAL;
70 BEGIN
71 RETURN LENGTH(stringVal);
72 END Length;
73
74
75 PROCEDURE CanAssignAll (sourceLength: CARDINAL;
76 VAR destination: ARRAY OF CHAR): BOOLEAN;
77 BEGIN
78 RETURN sourceLength <= HIGH(destination) + 1;
79 END CanAssignAll;
80
81
82 PROCEDURE Assign (source: ARRAY OF CHAR; VAR destination: ARRAY OF CHAR);
83 VAR ix, smaller : CARDINAL;
84 ch : CHAR;
85 BEGIN
86 IF HIGH(source) < HIGH(destination) THEN
87 smaller := HIGH(source);
88 ELSE
89 smaller := HIGH(destination);
90 END;
91 FOR ix := 0 TO smaller DO
92 ch := source[ix];
93 destination[ix] := ch;
94 IF ch = ASCII.nul THEN RETURN END;
95 END;
96 IF smaller < HIGH(destination) THEN
97 destination[smaller + 1] := ASCII.nul;
98 END;
99 END Assign;
100
101
102 PROCEDURE CanExtractAll (sourceLength, startIndex, numberToExtract: CARDINAL;
103 VAR destination: ARRAY OF CHAR): BOOLEAN;
104 BEGIN
105 RETURN (startIndex + numberToExtract <= sourceLength) AND
106 (numberToExtract <= HIGH(destination) + 1);
107 END CanExtractAll;
108
109
110 PROCEDURE Extract (source: ARRAY OF CHAR; startIndex, numberToExtract: CARDINAL;
111 VAR destination: ARRAY OF CHAR);
112 VAR dIx, lim : CARDINAL;
113 BEGIN
114 dIx := 0;
115 IF numberToExtract > 0 THEN (* else special case *)
116 DEC(numberToExtract);
117 IF numberToExtract > HIGH(destination) THEN
118 numberToExtract := HIGH(destination);
119 END;
120 lim := LENGTH(source);
121 IF startIndex + numberToExtract >= lim THEN DEC(lim);
122 ELSE lim := startIndex + numberToExtract;
123 END;
124 (* lim is last index to copy *)
125 WHILE startIndex <= lim DO
126 destination[dIx] := source[startIndex]; INC(startIndex); INC(dIx);
127 END;
128 END;
129 IF dIx <= HIGH(destination) THEN destination[dIx] := ASCII.nul END;
130 END Extract;
131
132
133 PROCEDURE CanDeleteAll (stringLength, startIndex, numberToDelete: CARDINAL): BOOLEAN;
134 BEGIN
135 RETURN startIndex + numberToDelete <= stringLength;
136 END CanDeleteAll;
137
138
139 PROCEDURE Delete (VAR string: ARRAY OF CHAR; startIndex, numberToDelete: CARDINAL);
140 VAR lim, mIx : CARDINAL;
141 BEGIN
142 lim := LENGTH(string);
143 IF startIndex < lim THEN (* else do nothing *)
144 IF startIndex + numberToDelete <= lim THEN (* else startIndex is unchanged *)
145 mIx := startIndex + numberToDelete;
146 WHILE mIx < lim DO
147 string[startIndex] := string[mIx]; INC(startIndex); INC(mIx);
148 END;
149 END;
150 IF startIndex <= HIGH(string) THEN string[startIndex] := ASCII.nul END;
151 END;
152 END Delete;
153
154
155 PROCEDURE CanInsertAll (sourceLength, startIndex: CARDINAL;
156 VAR destination: ARRAY OF CHAR): BOOLEAN;
157 VAR dLen : CARDINAL;
158 BEGIN
159 dLen := LENGTH(destination);
160 RETURN (startIndex <= dLen) AND (sourceLength + dLen <= HIGH(destination) +1);
161 END CanInsertAll;
162
163
164 PROCEDURE Insert (source: ARRAY OF CHAR; startIndex: CARDINAL;
165 VAR destination: ARRAY OF CHAR);
166 VAR dLen, sLen, rIx, ix : CARDINAL;
167 BEGIN
168 sLen := LENGTH(source);
169 dLen := LENGTH(destination);
170 IF (sLen = 0) OR (dLen <= startIndex) THEN RETURN END; (* trivial cases *)
171
172 (* copy excess characters up *)
173 rIx := dLen + sLen;
174 IF rIx > HIGH(destination) THEN
175 rIx := HIGH(destination);
176 IF rIx >= (sLen + startIndex) THEN
177 FOR ix := rIx - sLen TO startIndex BY -1 DO
178 destination[rIx] := destination[ix]; DEC(rIx);
179 END;
180 END;
181 ELSE
182 destination[rIx] := ASCII.nul; DEC(rIx);
183 FOR ix := dLen - 1 TO startIndex BY -1 DO
184 destination[rIx] := destination[ix]; DEC(rIx);
185 END;
186 END;
187
188 (* now copy in source string *)
189 DEC(sLen); (* assert : was not zero previously *)
190 IF sLen + startIndex > HIGH(destination) THEN
191 sLen := HIGH(destination) - startIndex;
192 END;
193 FOR ix := 0 TO sLen DO
194 destination[startIndex] := source[ix]; INC(startIndex);
195 END;
196 END Insert;
197
198
199 PROCEDURE CanReplaceAll (sourceLength, startIndex: CARDINAL;
200 VAR destination: ARRAY OF CHAR): BOOLEAN;
201 BEGIN
202 RETURN sourceLength + startIndex <= LENGTH(destination);
203 END CanReplaceAll;
204
205
206 PROCEDURE Replace (source: ARRAY OF CHAR; startIndex: CARDINAL;
207 VAR destination: ARRAY OF CHAR);
208 VAR dLen, ix : CARDINAL;
209 BEGIN
210 dLen := LENGTH(destination);
211 ix := 0;
212 WHILE (startIndex < dLen) AND
213 (ix <= HIGH(source)) AND (source[ix] <> ASCII.nul) DO
214 destination[startIndex] := source[ix]; INC(ix); INC(startIndex);
215 END;
216 END Replace;
217
218
219 PROCEDURE CanAppendAll (sourceLength: CARDINAL;
220 VAR destination: ARRAY OF CHAR): BOOLEAN;
221 BEGIN
222 RETURN LENGTH(destination) + sourceLength <= HIGH(destination) + 1;
223 END CanAppendAll;
224
225
226 PROCEDURE Append (source: ARRAY OF CHAR; VAR destination: ARRAY OF CHAR);
227 VAR sIx, dIx, lim : CARDINAL;
228 BEGIN
229 dIx := LENGTH(destination);
230 IF HIGH(source) + dIx < HIGH(destination) THEN
231 lim := HIGH(source) + dIx;
232 ELSE
233 lim := HIGH(destination);
234 END;
235 sIx := 0;
236 WHILE dIx <= lim DO
237 destination[dIx] := source[sIx];
238 IF source[sIx] = ASCII.nul THEN RETURN END;
239 INC(sIx); INC(dIx);
240 END;
241 IF dIx <= HIGH(destination) THEN destination[dIx] := ASCII.nul END;
242 END Append;
243
244
245 PROCEDURE CanConcatAll (source1Length, source2Length: CARDINAL;
246 VAR destination: ARRAY OF CHAR): BOOLEAN;
247 BEGIN
248 RETURN source1Length + source2Length <= HIGH(destination) + 1;
249 END CanConcatAll;
250
251
252 PROCEDURE Concat (source1, source2: ARRAY OF CHAR; VAR destination: ARRAY OF CHAR);
253 VAR dIx, sIx, lim : CARDINAL;
254 BEGIN
255 IF HIGH(source1) < HIGH(destination) THEN
256 lim := HIGH(source1);
257 ELSE
258 lim := HIGH(destination);
259 END;
260 dIx := 0;
261 WHILE (dIx <= lim) AND (source1[dIx] <> ASCII.nul) DO
262 destination[dIx] := source1[dIx]; INC(dIx);
263 END;
264
265 IF HIGH(source2) + lim < HIGH(destination) THEN
266 lim := HIGH(source2) + lim;
267 ELSE
268 lim := HIGH(destination);
269 END;
270 sIx := 0;
271 WHILE dIx <= lim DO
272 destination[dIx] := source2[sIx];
273 IF source2[sIx] = ASCII.nul THEN RETURN END;
274 INC(sIx); INC(dIx);
275 END;
276 IF dIx <= HIGH(destination) THEN destination[dIx] := ASCII.nul END;
277 END Concat;
278
279
280 PROCEDURE Capitalize(VAR stringVar : ARRAY OF CHAR);
281 VAR ix : CARDINAL;
282 BEGIN
283 ix := 0;
284 WHILE (ix <= HIGH(stringVar)) AND (stringVar[ix] <> ASCII.nul) DO
285 stringVar[ix] := CAP(stringVar[ix]);
286 INC(ix);
287 END;
288 END Capitalize;
289
290
291 (*
292 * There are two different versions of Compare here.
293 * They use different algorithms which have been
294 * tuned for statistically good behaviour. The first
295 * one is usually faster, but neither is as good
296 * as the libc's strncmp.
297 *
298 * Is it worthwhile to define an interface module to strncmp?
299 *
300 *)
301 PROCEDURE Compare (stringVal1 : ARRAY OF CHAR;
302 stringVal2 : ARRAY OF CHAR) : CompareResults;
303 VAR s1, s2 : CHAR;
304 ix, lim : CARDINAL;
305 BEGIN
306 s1 := stringVal1[0]; s2 := stringVal2[0];
307 IF s1 < s2 THEN RETURN less;
308 ELSIF s1 > s2 THEN RETURN greater;
309 ELSE
310 lim := HIGH(stringVal1);
311 IF lim > HIGH(stringVal2) THEN lim := HIGH(stringVal2) END;
312 ix := 0;
313 IF stringVal1[lim] <> stringVal2[lim] THEN (* loop terminates before smaller high *)
314 LOOP
315 IF s1 = s2 THEN
316 IF s2 = ASCII.nul THEN RETURN equal END;
317 INC(ix); s1:= stringVal1[ix]; s2 := stringVal2[ix];
318 ELSIF s1 < s2 THEN RETURN less;
319 ELSE RETURN greater;
320 END;
321 END;
322 END;
323 WHILE ix < lim DO
324 IF s1 = s2 THEN
325 IF s2 = ASCII.nul THEN RETURN equal END;
326 INC(ix); s1:= stringVal1[ix]; s2 := stringVal2[ix];
327 ELSIF s1 < s2 THEN RETURN less;
328 ELSE RETURN greater;
329 END;
330 END;
331 (* Assert((s1 = s2) AND (ix = lim)); *)
332 IF s2 = ASCII.nul THEN RETURN equal;
333 ELSIF HIGH(stringVal2) > lim THEN
334 IF stringVal2[lim + 1] = ASCII.nul THEN RETURN equal ELSE RETURN less END;
335 ELSIF HIGH(stringVal1) > lim THEN
336 IF stringVal1[lim + 1] = ASCII.nul THEN RETURN equal ELSE RETURN greater END;
337 END;
338 RETURN equal;
339 END;
340 END Compare;
341
342 (* --------------------------------------------------------
343 PROCEDURE Compare (str1 : ARRAY OF CHAR;
344 str2 : ARRAY OF CHAR) : CompareResults;
345 VAR s1, s2 : CHAR; ix, lim, lim1, lim2 : CARDINAL;
346 BEGIN
347 IF str1[0] <> str2[0] THEN
348 IF str1[0] > str2[0] THEN RETURN less;
349 ELSE RETURN greater;
350 END;
351 ELSE
352 IF str1[0] = ASCII.nul THEN RETURN equal END;
353 lim1 := HIGH(str1) + 1;
354 lim2 := HIGH(str2) + 1;
355 s1 := str1[1]; s2 := str2[1]; ix := 1;
356 IF str2[lim2] = ASCII.nul THEN (* simple is safe *)
357 WHILE s1 = s2 DO
358 IF s1 = ASCII.nul THEN RETURN equal END;
359 INC(ix); s1 := str1[ix]; s2 := str2[ix];
360 END;
361 (* chars are different *)
362 IF ix >= lim1 THEN
363 IF s2 = ASCII.nul THEN RETURN equal;
364 ELSE RETURN less;
365 END;
366 ELSIF s1 < s2 THEN RETURN less;
367 ELSE RETURN greater;
368 END;
369 ELSIF str1[lim1] = ASCII.nul THEN (* simple is safe *)
370 WHILE s1 = s2 DO
371 IF s1 = ASCII.nul THEN RETURN equal END;
372 INC(ix); s1 := str1[ix]; s2 := str2[ix];
373 END;
374 (* chars are different *)
375 IF ix >= lim2 THEN
376 IF s1 = ASCII.nul THEN RETURN equal;
377 ELSE RETURN greater;
378 END;
379 ELSIF s1 < s2 THEN RETURN less;
380 ELSE RETURN greater;
381 END;
382 ELSE (* must do full test *)
383 IF lim1 <= lim2 THEN lim := lim1 ELSE lim := lim2 END;
384 WHILE ix < lim DO
385 IF s1 = s2 THEN
386 IF s2 = ASCII.nul THEN RETURN equal;
387 ELSE INC(ix); s1 := str1[ix]; s2 := str2[ix];
388 END;
389 ELSIF s1 < s2 THEN RETURN less;
390 ELSE RETURN greater;
391 END;
392 END;
393 IF lim2 > lim THEN (* only lim1 is known to be ended *)
394 IF s2 <> ASCII.nul THEN RETURN less;
395 ELSE RETURN equal;
396 END;
397 ELSIF lim1 > lim THEN
398 IF s1 <> ASCII.nul THEN RETURN greater;
399 ELSE RETURN equal;
400 END;
401 ELSE RETURN equal;
402 END;
403 END;
404 END;
405 END Compare;
406 -------------------------------------------------------- *)
407
408
409 PROCEDURE Equal (stringVal1, stringVal2: ARRAY OF CHAR): BOOLEAN;
410 BEGIN
411 RETURN Compare(stringVal1, stringVal2) = equal;
412 END Equal;
413
414
415 PROCEDURE FindNext (pattern, stringToSearch: ARRAY OF CHAR; startIndex: CARDINAL;
416 VAR patternFound: BOOLEAN; VAR posOfPattern: CARDINAL);
417 VAR sLen, pLen, px, sx : CARDINAL;
418 BEGIN
419 sLen := LENGTH(stringToSearch);
420 pLen := LENGTH(pattern);
421 IF pLen > sLen THEN patternFound := FALSE; RETURN END;
422
423 IF pLen = 0 THEN (* What are the semantics here? *)
424 patternFound := startIndex < sLen;
425 posOfPattern := startIndex; (* Martin says "" matches any character *)
426 RETURN;
427 END;
428
429 WHILE startIndex <= sLen - pLen DO (* find potential starting points *)
430 IF stringToSearch[startIndex] = pattern[0] THEN
431 px := 0; sx := startIndex; (* now compare strings *)
432 LOOP
433 INC(px); INC(sx);
434 IF px = pLen THEN
435 patternFound := TRUE;
436 posOfPattern := startIndex;
437 RETURN;
438 ELSIF pattern[px] <> stringToSearch[sx] THEN
439 EXIT;
440 END;
441 END; (* loop *)
442 END;
443 INC(startIndex);
444 END;
445 patternFound := FALSE;
446 END FindNext;
447
448
449 PROCEDURE FindPrev (pattern, stringToSearch: ARRAY OF CHAR; startIndex: CARDINAL;
450 VAR patternFound: BOOLEAN; VAR posOfPattern: CARDINAL);
451 VAR sLen, pLen, sx, px : CARDINAL;
452 BEGIN
453 sLen := LENGTH(stringToSearch);
454 pLen := LENGTH(pattern);
455 IF pLen > sLen THEN patternFound := FALSE; RETURN END;
456
457 IF pLen = 0 THEN (* What are the semantics here? *)
458 patternFound := TRUE;
459 IF startIndex >= sLen THEN
460 posOfPattern := sLen - 1;
461 ELSE
462 posOfPattern := startIndex;
463 END;
464 RETURN;
465 END;
466
467 (* if startIndex > sLen - pLen the whole string is searched *)
468 IF startIndex > sLen - pLen THEN startIndex := sLen - pLen END;
469
470 (* now find potential starting points *)
471 INC(startIndex); (* so it doesn't go negative *)
472 WHILE startIndex > 0 DO
473 DEC(startIndex);
474 IF stringToSearch[startIndex] = pattern[0] THEN
475 px := 0; sx := startIndex; (* now compare strings *)
476 LOOP
477 INC(px); INC(sx);
478 IF px = pLen THEN
479 patternFound := TRUE;
480 posOfPattern := startIndex;
481 RETURN;
482 ELSIF pattern[px] <> stringToSearch[sx] THEN
483 EXIT;
484 END;
485 END; (* loop *)
486 END;
487 END;
488 patternFound := FALSE;
489 END FindPrev;
490
491
492 PROCEDURE FindDiff (stringVal1, stringVal2: ARRAY OF CHAR;
493 VAR differenceFound: BOOLEAN; VAR posOfDifference: CARDINAL);
494 VAR ix : CARDINAL;
495 BEGIN
496 ix := 0;
497 IF stringVal1[0] = stringVal2[0] THEN
498 IF stringVal1[0] = ASCII.nul THEN (* both strings empty *)
499 differenceFound := FALSE; RETURN;
500 END;
501 LOOP
502 INC(ix);
503 IF (ix > HIGH(stringVal1)) OR (stringVal1[ix] = ASCII.nul) THEN (* 1 ended *)
504 IF (ix > HIGH(stringVal2)) OR (stringVal2[ix] = ASCII.nul) THEN (* 2 also *)
505 differenceFound := FALSE; RETURN; (* both ended, and equal *)
506 ELSE
507 EXIT; (* only 1 ended *)
508 END;
509 ELSIF (ix > HIGH(stringVal2)) OR (stringVal2[ix] = ASCII.nul) THEN
510 EXIT; (* only 2 ended *)
511 ELSIF stringVal1[ix] <> stringVal2[ix] THEN
512 EXIT; (* strings differ *)
513 (* else go around the loop once more *)
514 END;
515 END; (* loop *)
516 END;
517 differenceFound := TRUE;
518 posOfDifference := ix;
519 END FindDiff;
520
521 END Strings2.