Changeset 390 for trunk

Timestamp:

Apr 30, 2016, 7:49:57 PM (9 years ago)

Author:

RBRi

Message:

more string utils (merged from old 2.20)

Location:

trunk

Files:

• Library/StringUtilsUnit.pas (modified) (7 diffs)
• unittests/StringUtilsUnitTests.pas (modified) (6 diffs)

trunk/Library/StringUtilsUnit.pas

@@ -2 +2 @@
 
 // NewView - a new OS/2 Help Viewer
-// Copyright 2006-2007 Ronald Brill (rbri at rbri dot de)
+// Copyright 2003-2006 Aaron Lawrence
+// Copyright 2006-2009 Ronald Brill (rbri at rbri dot de)
 // This software is released under the GNU Public License - see readme.txt
 
@@ -106 +107 @@
   Function LongWordToStr(const aLongWord: LongWord) : String;
 
-  Function BoolToStr(const aBoolean : boolean ): string;
+  Function BoolToStr(const aBoolean : Boolean ): String;
+
+  // Converts a hex string to a longint
+  // May be upper or lower case
+  // Does not allow a sign
+  // Is not forgiving as StrToInt: all characters
+  // must be valid hex chars.
+  Function HexStrToLongInt(const aString : String ): longint;
 
   // Returns aString enclosed in single quotes
@@ -116 +124 @@
   // Extract all fields in a String delimited by whitespace (blank or tab).
   // use double quotes if you need blanks in the strings
-  Procedure StrExtractStringsQuoted(Var aResult: TStrings; const aReceiver: String );
-
+  Procedure StrExtractStringsQuoted(Var aResult: TStrings; const aReceiver: String);
 
   // returns the position of aPart in aString
   // case insensitive
-  Function CaseInsensitivePos(const aPart: String; const aString: String ): longint;
+  Function CaseInsensitivePos(const aPart: String; const aString: String) : longint;
 
   // Finds the last position of aChar within aString. Returns zero if no match
-  Function LastPosOfChar(const aChar: char; const aString: String): longint;
+  Function LastPosOfChar(const aChar: char; const aString: String) : longint;
+
+
+  // Substitutes all occurences of given character with the replace char
+  Procedure SubstituteAllOccurencesOfChar(var aReceiver: String; const aSearchChar: Char; const aReplaceChar: Char);
 
 
@@ -668 +679 @@
 
 
+// Hex conversion: sheer extravagance. Conversion from
+// a hex digit char to int is done by creating a lookup table
+// in advance.
+var
+  MapHexDigitToInt: array[Chr(0) .. Chr(255)] of longint;
+
+  procedure InitHexDigitMap;
+  var
+    tmpChar : char;
+    tmpIntValue : longint;
+  begin
+    for tmpChar := Chr(0) to Chr(255) do
+    begin
+      tmpIntValue := -1;
+      if ( tmpChar >= '0') and (tmpChar <= '9') then
+      begin
+        tmpIntValue := Ord(tmpChar) - Ord('0');
+      end;
+
+      if ( Upcase(tmpChar) >= 'A') and (Upcase(tmpChar) <= 'F') then
+      begin
+        tmpIntValue := 10 + Ord(Upcase(tmpChar)) - Ord('A');
+      end;
+
+      MapHexDigitToInt[tmpChar] := tmpIntValue;
+    end;
+  end;
+
+
+  Function HexDigitToInt(const aString : String; const aPosition : integer) : longint;
+  begin
+    Result := MapHexDigitToInt[aString[aPosition]];
+    if Result = -1 then
+    begin
+      raise EConvertError.Create('Invalid hex char: ''' + aString[aPosition] + ''' in hex string ''' + aString +'''.' );
+    end
+  end;
+
+
+  Function HexStrToLongInt(const aString : String) : longint;
+  var
+    i: integer;
+  begin
+    if Length(aString) = 0 then
+    begin
+      raise EConvertError.Create('No chars in hex string');
+    end;
+
+    Result := 0;
+    for i:= 1 to Length(aString) do
+    begin
+      Result := Result shl 4;
+      inc(Result, HexDigitToInt(aString, i));
+    end;
+  end;
+
   Function StrInSingleQuotes(const aString : String) : String;
   begin
@@ -680 +747 @@
 
 
-  Procedure StrExtractStringsQuoted(Var aResult: TStrings; const aReceiver: String );
+  Procedure StrExtractStringsQuoted(Var aResult: TStrings; const aReceiver: String);
   Var
     tmpState : (WHITESPACE, INSIDE, START_QUOTE, INSIDE_QUOTED, INSIDE_QUOTED_START_QUOTE);
@@ -939 +1006 @@
   end;
 
+
+  Procedure SubstituteAllOccurencesOfChar(var aReceiver: String; const aSearchChar: Char; const aReplaceChar: Char );
+  var
+    i : longint;
+  begin
+    for i :=1 to length(aReceiver) do
+    begin
+      if aReceiver[i] = aSearchChar then
+      begin
+        aReceiver[i] := aReplaceChar;
+      end
+    end
+  end;
+
+
   // --------------------
   // ---- AnsiString ----
@@ -1096 +1178 @@
   end;
 
-END.
+
+Initialization
+  InitHexDigitMap;
+End.

trunk/unittests/StringUtilsUnitTests.pas

@@ -1 +1 @@
 Unit StringUtilsUnitTests;
+
+// NewView - a new OS/2 Help Viewer
+// Copyright 2006-2009 Ronald Brill (rbri at rbri dot de)
+// This software is released under the GNU Public License - see readme.txt
+
+// UnitTests for StringUtilsUnit
 
 Interface
@@ -1574 +1580 @@
 
 
+  PROCEDURE testHexStrToLongInt_Empty;
+  VAR
+    tmpResult : LongInt;
+  BEGIN
+    tmpResult := -1;
+    try
+      tmpResult := HexStrToLongInt('');
+    except
+      on e:EConvertError do
+      begin
+        assertEqualsString('testHexStrToLongInt_Empty', 'No chars in hex string', e.message);
+      end;
+    end;
+
+
+    assertEqualsInt('testHexStrToLongInt_Empty', -1, tmpResult);
+  END;
+
+
+  PROCEDURE testHexStrToLongInt_IllegalChar;
+  VAR
+    tmpResult : LongInt;
+  BEGIN
+    tmpResult := -1;
+    try
+      tmpResult := HexStrToLongInt('abG');
+    except
+      on e:EConvertError do
+      begin
+        assertEqualsString('testHexStrToLongInt_IllegalChar', 'Invalid hex char: ''G'' in hex string ''abG''.', e.message);
+      end;
+    end;
+
+
+    assertEqualsInt('testHexStrToLongInt_IllegalChar', -1, tmpResult);
+  END;
+
+
+  PROCEDURE testHexStrToLongInt_IllegalCharMinus;
+  VAR
+    tmpResult : LongInt;
+  BEGIN
+    tmpResult := -1;
+    try
+      tmpResult := HexStrToLongInt('-F3');
+    except
+      on e:EConvertError do
+      begin
+        assertEqualsString('testHexStrToLongInt_IllegalCharMinus', 'Invalid hex char: ''-'' in hex string ''-F3''.', e.message);
+      end;
+    end;
+
+
+    assertEqualsInt('testHexStrToLongInt_IllegalCharMinus', -1, tmpResult);
+  END;
+
+
+  PROCEDURE testHexStrToLongInt_Zero;
+  VAR
+    tmpResult : LongInt;
+  BEGIN
+    tmpResult := HexStrToLongInt('000');
+
+    assertEqualsInt('testHexStrToLongInt_Zero', 0, tmpResult);
+  END;
+
+
+  PROCEDURE testHexStrToLongInt_Ten;
+  VAR
+    tmpResult : LongInt;
+  BEGIN
+    tmpResult := HexStrToLongInt('A');
+
+    assertEqualsInt('testHexStrToLongInt_Ten', 10, tmpResult);
+  END;
+
+
+  PROCEDURE testHexStrToLongInt_Big;
+  VAR
+    tmpResult : LongInt;
+  BEGIN
+    tmpResult := HexStrToLongInt('7fffFFFF');
+
+    assertEqualsLongWord('testHexStrToLongInt_Big', 2147483647, tmpResult);
+  END;
+
+
+  // ----------------------------------------------------------
+
+
   PROCEDURE testStrInSingleQuotes_Empty;
   VAR
@@ -1975 +2071 @@
 
 
-
   // -------------------------------------------------------------------
 
@@ -2066 +2161 @@
 
     assertEqualsInt('testLastPosOfChar_ManyHits', 7, tmpResult);
+  END;
+
+
+  // -------------------------------------------------------------------
+
+
+  PROCEDURE testSubstituteAllOccurencesOfChar_Empty;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := '';
+    SubstituteAllOccurencesOfChar(tmpResult, 'x', 'y');
+
+    assertEqualsString('testSubstituteAllOccurencesOfChar_Empty', '', tmpResult);
+  END;
+
+
+  PROCEDURE testSubstituteAllOccurencesOfChar_NotFound;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := 'abc';
+    SubstituteAllOccurencesOfChar(tmpResult, 'x', 'y');
+
+    assertEqualsString('testSubstituteAllOccurencesOfChar_NotFound', 'abc', tmpResult);
+  END;
+
+
+  PROCEDURE testSubstituteAllOccurencesOfChar_OneCharReplace;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := 'x';
+    SubstituteAllOccurencesOfChar(tmpResult, 'x', 'y');
+
+    assertEqualsString('testSubstituteAllOccurencesOfChar_OneCharReplace', 'y', tmpResult);
+  END;
+
+
+  PROCEDURE testSubstituteAllOccurencesOfChar_ReplaceAll;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := 'xxxx';
+    SubstituteAllOccurencesOfChar(tmpResult, 'x', 'y');
+
+    assertEqualsString('testSubstituteAllOccurencesOfChar_ReplaceAll', 'yyyy', tmpResult);
+  END;
+
+
+  PROCEDURE testSubstituteAllOccurencesOfChar_Some;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := 'xabxcxddx';
+    SubstituteAllOccurencesOfChar(tmpResult, 'x', 'y');
+
+    assertEqualsString('testSubstituteAllOccurencesOfChar_Some', 'yabycyddy', tmpResult);
   END;
 
@@ -2575 +2728 @@
     result.add(@testStrInSingleQuotes_Empty);
     result.add(@testStrInSingleQuotes);
+
+    result.add(@testHexStrToLongInt_Empty);
+    result.add(@testHexStrToLongInt_IllegalChar);
+    result.add(@testHexStrToLongInt_IllegalCharMinus);
+    result.add(@testHexStrToLongInt_Zero);
+    result.add(@testHexStrToLongInt_Ten);
+    result.add(@testHexStrToLongInt_Big);
 
     result.add(@testStrInDoubleQuotes_Empty);
@@ -2614 +2774 @@
     result.add(@testLastPosOfChar_ManyHits);
 
+    result.add(@testSubstituteAllOccurencesOfChar_Empty);
+    result.add(@testSubstituteAllOccurencesOfChar_NotFound);
+    result.add(@testSubstituteAllOccurencesOfChar_OneCharReplace);
+    result.add(@testSubstituteAllOccurencesOfChar_ReplaceAll);
+    result.add(@testSubstituteAllOccurencesOfChar_Some);
 
   // --------------------