Changeset 139

Timestamp:

Apr 30, 2007, 9:00:32 PM (18 years ago)

Author:

RBRi

Message:

more refactoring

Location:

trunk/NewView

Files:

• CharUtilsUnit.pas (modified) (1 diff)
• StringUtilsUnit.pas (modified) (12 diffs)
• unittests/StringUtilsUnitTests.pas (modified) (8 diffs)

trunk/NewView/CharUtilsUnit.pas

@@ -16 +16 @@
   CharCR = chr(13);
   CharLF = chr(10);
+  CharSingleQuote = '''';
+  CharDoubleQuote = '"';
 
 

trunk/NewView/StringUtilsUnit.pas

@@ -18 +18 @@
   StrLF = CharLF;
   StrCRLF = StrCR + StrLF;
-  StrSingleQuote = '''';
-  StrDoubleQuote = '"';
+  StrSingleQuote = CharSingleQuote;
+  StrDoubleQuote = CharDoubleQuote;
 
 
@@ -37 +37 @@
   end;
 
-  // prefices all occurences of one of the chars in aStringWithChars with anEscape char
+  // prefixes all occurences of one of the chars in aStringWithChars with anEscape char
   // if the escapeChar itself is found, then it is doubled
   Function StrEscapeAllCharsBy(const aReceiver: String; const aSetOfChars: TSetOfChars; const anEscapeChar: char): String;
@@ -94 +94 @@
   Function StrEndsWithIgnoringCase(const aReceiver: String; const anEndString: String): Boolean;
 
+  // Returns true if aReceiver is only spaces (or empty)
+  Function StrIsEmptyOrSpaces(const aReceiver: String) : Boolean;
+
   // returns true if the Strings are the same
   // this is case INsensitive
@@ -105 +108 @@
   Function BoolToStr(const aBoolean : boolean ): string;
 
+  // Returns aString enclosed in single quotes
+  Function StrInSingleQuotes(const aString : String) : String;
+
   // Returns aString enclosed in double quotes
   Function StrInDoubleQuotes(const aString : String) : String;
@@ -117 +123 @@
   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;
+
 
   // --------------------
@@ -122 +131 @@
   // --------------------
 
-  
+
   // removes all occurences of char from aSetOfChars from the beginning
   // of a String.
@@ -139 +148 @@
 
 
+  // --------------------
+  // ---- Misc TODO  ----
+  // --------------------
+
+  Procedure GetMemString(const aPointer : pointer; var aString: string; const aSize: byte);
+
+  Procedure FreePString(var aPString: PString );
+
+  Function NewPString(const aString : String) : PString;
 
 
@@ -145 +163 @@
   uses
     SysUtils,
-    DebugUnit;
+    DebugUnit,
+    ACLUtility;  // TODO
 
   constructor TSerializableStringList.Create;
@@ -568 +587 @@
 
 
+  Function StrIsEmptyOrSpaces(const aReceiver: String) : Boolean;
+  Begin
+    Asm
+      MOV ESI, aReceiver   // get address of aReceiver into ESI
+      MOV CL,[ESI]     // get length of s
+      MOVZX ECX, CL      // widen CL
+      INC ECX
+
+    !IsSpacesLoop:
+      INC ESI   // move to next char
+      DEC ECX
+      JE !IsSpacesTrue
+
+      MOV AL,[ESI] // load character
+      CMP AL,32  // is it a space?
+      JE !IsSpacesLoop // yes, go to next
+
+      // no, return false
+      MOV EAX, 0
+      JMP !IsSpacesDone
+
+    !IsSpacesTrue:
+      MOV EAX, 1
+
+    !IsSpacesDone:
+      LEAVE
+      RETN32 4
+    End;
+  End;
+
+
   Function StrEqualIgnoringCase(const aReceiver: String; const aSecondString: String): Boolean;
   begin
@@ -618 +668 @@
 
 
+  Function StrInSingleQuotes(const aString : String) : String;
+  begin
+    Result := StrSingleQuote + aString + StrSingleQuote;
+  end;
+
+
   Function StrInDoubleQuotes(const aString : String) : String;
   begin
@@ -866 +922 @@
 
 
+  Function LastPosOfChar(const aChar: char; const aString: String): longint;
+  Var
+    tmpPos : longint;
+  begin
+    tmpPos := Length(aString);
+    while tmpPos > 0 do
+    begin
+      if aString[tmpPos] = aChar then
+      begin
+        Result := tmpPos;
+        exit;
+      end;
+      dec(tmpPos);
+    end;
+    Result := 0;
+  end;
+
   // --------------------
   // ---- AnsiString ----
@@ -994 +1067 @@
 
 
+  // --------------------
+  // ---- Misc TODO  ----
+  // --------------------
+
+  Procedure GetMemString(const aPointer : pointer; var aString: string; const aSize: byte);
+  begin
+    aString[0] := char(aSize);
+    MemCopy(aPointer, Addr(aString[1]), aSize);
+  end;
+
+
+  Procedure FreePString(var aPString : PString );
+  begin
+    if aPString = nil then
+    begin
+      exit;
+    end;
+
+    FreeMem(aPString, Length(aPString^) + 1);
+    aPString := nil;
+  end;
+
+
+  Function NewPString(const aString : String) : PString;
+  begin
+    GetMem(Result, Length(aString) + 1);
+    Result^ := aString;
+  end;
+
 END.

trunk/NewView/unittests/StringUtilsUnitTests.pas

@@ -280 +280 @@
 
 
+  PROCEDURE testEscapeAllCharsBy_NoCharactersToEscape;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrEscapeAllCharsBy('a\bc\\de', [], '\');
+
+    assertEqualsString('testEscapeAllCharsBy_NoCharactersToEscape', 'a\\bc\\\\de', tmpResult);
+  END;
+
+
+  PROCEDURE testEscapeAllCharsBy_DoubleDoubleQuotes;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrEscapeAllCharsBy('"ab cd"e', [], '"');
+
+    assertEqualsString('testEscapeAllCharsBy_DoubleDoubleQuotes', '""ab cd""e', tmpResult);
+  END;
+
+
   // ------------------------------------------------------
 
@@ -1368 +1388 @@
 
 
+  PROCEDURE testStrIsEmptyOrSpaces_Empty;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrIsEmptyOrSpaces('');
+
+    assertTrue('testStrIsEmptyOrSpaces_Empty', tmpResult);
+  END;
+
+
+  PROCEDURE testStrIsEmptyOrSpaces_OneSpace;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrIsEmptyOrSpaces(' ');
+
+    assertTrue('testStrIsEmptyOrSpaces_OneSpace', tmpResult);
+  END;
+
+
+  PROCEDURE testStrIsEmptyOrSpaces_ManySpaces;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrIsEmptyOrSpaces('        ');
+
+    assertTrue('testStrIsEmptyOrSpaces_ManySpaces', tmpResult);
+  END;
+
+
+  PROCEDURE testStrIsEmptyOrSpaces_OneChar;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrIsEmptyOrSpaces('a');
+
+    assertFalse('testStrIsEmptyOrSpaces_OneChar', tmpResult);
+  END;
+
+
+  PROCEDURE testStrIsEmptyOrSpaces_ManyChars;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrIsEmptyOrSpaces('abcde');
+
+    assertFalse('testStrIsEmptyOrSpaces_ManyChars', tmpResult);
+  END;
+
+
+  PROCEDURE testStrIsEmptyOrSpaces_SpacesWithOneChar;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrIsEmptyOrSpaces('       z     ');
+
+    assertFalse('testStrIsEmptyOrSpaces_SpacesWithOneChar', tmpResult);
+  END;
+
+
+  PROCEDURE testStrIsEmptyOrSpaces_CharZero;
+  VAR
+    tmpResult : Boolean;
+  BEGIN
+    tmpResult := StrIsEmptyOrSpaces(#0);
+
+    assertFalse('testStrIsEmptyOrSpaces_CharZero', tmpResult);
+  END;
+
+
+  // ----------------------------------------------------------
+
+
   PROCEDURE testStrEqualIgnoringCase_BothEmpty;
   VAR
@@ -1475 +1568 @@
 
     assertEqualsString('testBoolToStr_false', 'False', tmpResult);
+  END;
+
+
+  // ----------------------------------------------------------
+
+
+  PROCEDURE testStrInSingleQuotes_Empty;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrInSingleQuotes('');
+
+    assertEqualsString('testStrInSingleQuotes_Empty', '''''', tmpResult);
+  END;
+
+
+  PROCEDURE testStrInSingleQuotes;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrInSingleQuotes('abc');
+
+    assertEqualsString('testStrInSingleQuotes', '''abc''', tmpResult);
   END;
 
@@ -1856 +1972 @@
     tmpResult := CaseInsensitivePos(LowerCase(tmpPart), tmpString);
     assertEqualsInt('testCaseInsensitivePos', 1, tmpResult);
-END;
+  END;
+
+
+
+  // -------------------------------------------------------------------
+
+
+  PROCEDURE testLastPosOfChar_Empty;
+  VAR
+    tmpResult : longint;
+  BEGIN
+    tmpResult := LastPosOfChar('x', '');
+
+    assertEqualsInt('testLastPosOfChar_Empty', 0, tmpResult);
+  END;
+
+
+  PROCEDURE testLastPosOfChar_NotFound;
+  VAR
+    tmpResult : longint;
+  BEGIN
+    tmpResult := LastPosOfChar('x', 'abcd');
+
+    assertEqualsInt('testLastPosOfChar_NotFound', 0, tmpResult);
+  END;
+
+
+  PROCEDURE testLastPosOfChar_OneCharNotFound;
+  VAR
+    tmpResult : longint;
+  BEGIN
+    tmpResult := LastPosOfChar('x', 'a');
+
+    assertEqualsInt('testLastPosOfChar_OneCharNotFound', 0, tmpResult);
+  END;
+
+
+  PROCEDURE testLastPosOfChar_OneCharFound;
+  VAR
+    tmpResult : longint;
+  BEGIN
+    tmpResult := LastPosOfChar('x', 'x');
+
+    assertEqualsInt('testLastPosOfChar_OneCharFound', 1, tmpResult);
+  END;
+
+
+  PROCEDURE testLastPosOfChar_OneCharWrongCase;
+  VAR
+    tmpResult : longint;
+  BEGIN
+    tmpResult := LastPosOfChar('x', 'X');
+
+    assertEqualsInt('testLastPosOfChar_OneCharWrongCase', 0, tmpResult);
+  END;
+
+
+  PROCEDURE testLastPosOfChar_FirstChar;
+  VAR
+    tmpResult : longint;
+  BEGIN
+    tmpResult := LastPosOfChar('x', 'xabcd');
+
+    assertEqualsInt('testLastPosOfChar_FirstChar', 1, tmpResult);
+  END;
+
+
+  PROCEDURE testLastPosOfChar_LastChar;
+  VAR
+    tmpResult : longint;
+  BEGIN
+    tmpResult := LastPosOfChar('x', 'abcdx');
+
+    assertEqualsInt('testLastPosOfChar_LastChar', 5, tmpResult);
+  END;
+
+
+  PROCEDURE testLastPosOfChar_MiddleChar;
+  VAR
+    tmpResult : longint;
+  BEGIN
+    tmpResult := LastPosOfChar('x', 'abcdxwertzu');
+
+    assertEqualsInt('testLastPosOfChar_MiddleChar', 5, tmpResult);
+  END;
+
+
+  PROCEDURE testLastPosOfChar_ManyHits;
+  VAR
+    tmpResult : longint;
+  BEGIN
+    tmpResult := LastPosOfChar('x', 'axbcxdxu');
+
+    assertEqualsInt('testLastPosOfChar_ManyHits', 7, tmpResult);
+  END;
 
 
@@ -2227 +2437 @@
     result.add(@testEscapeAllCharsBy_EmptyChars);
     result.add(@testEscapeAllCharsBy_EscapeEscape);
+    result.add(@testEscapeAllCharsBy_NoCharactersToEscape);
+    result.add(@testEscapeAllCharsBy_DoubleDoubleQuotes);
 
     result.add(@testStrExtractStrings_EmptyReceiver);
@@ -2339 +2551 @@
     result.add(@testStrEndsWithIgnoringCase_StringMatchCaseInSensitive);
 
+    result.add(@testStrIsEmptyOrSpaces_Empty);
+    result.add(@testStrIsEmptyOrSpaces_OneSpace);
+    result.add(@testStrIsEmptyOrSpaces_ManySpaces);
+    result.add(@testStrIsEmptyOrSpaces_OneChar);
+    result.add(@testStrIsEmptyOrSpaces_ManyChars);
+    result.add(@testStrIsEmptyOrSpaces_SpacesWithOneChar);
+    result.add(@testStrIsEmptyOrSpaces_CharZero);
+
     result.add(@testStrEqualIgnoringCase_BothEmpty);
     result.add(@testStrEqualIgnoringCase_FirstEmpty);
@@ -2352 +2572 @@
     result.add(@testBoolToStr_true);
     result.add(@testBoolToStr_false);
+
+    result.add(@testStrInSingleQuotes_Empty);
+    result.add(@testStrInSingleQuotes);
 
     result.add(@testStrInDoubleQuotes_Empty);
@@ -2381 +2604 @@
     result.add(@testCaseInsensitivePos);
 
+    result.add(@testLastPosOfChar_Empty);
+    result.add(@testLastPosOfChar_NotFound);
+    result.add(@testLastPosOfChar_OneCharNotFound);
+    result.add(@testLastPosOfChar_OneCharFound);
+    result.add(@testLastPosOfChar_OneCharWrongCase);
+    result.add(@testLastPosOfChar_FirstChar);
+    result.add(@testLastPosOfChar_LastChar);
+    result.add(@testLastPosOfChar_MiddleChar);
+    result.add(@testLastPosOfChar_ManyHits);
+
+
   // --------------------
   // ---- AnsiString ----