| 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. |