hyperstr.pas

String hanlding library. Functions for crypto, token etc

//*** HYPERSTR v6.00 - (c)1996-2001, EFD Systems ***
//
//This source code is licensed for the private personal use of
//our clients and may not be re-distributed under any circumstances.
//
//THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
//ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
//THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//PARTICULAR PURPOSE.

{$B-,H+,X+,J-,O+} //Essential directives
{$IFDEF VER140}
{$WARN SYMBOL_PLATFORM OFF}
{$ENDIF}

unit HyperStr;

interface

uses
  Windows, Messages, SysUtils, WinSock, WinSpool;

type
  IDateTime      = type Integer;
  TIntegerArray  = array[0..(MaxInt div SizeOf(Integer))-1] of Integer;
  TWordArray     = array[0..(MaxInt div SizeOf(Word))-1] of Word;
  TSingleArray   = array[0..(MaxInt div SizeOf(Single))-1] of Single;
  TDoubleArray   = array[0..(MaxInt div SizeOf(Double))-1] of Double;
  TCurrencyArray = array[0..(MaxInt div SizeOf(Currency))-1] of Currency;
  TPointerArray  = array[0..(MaxInt div SizeOf(Pointer))-1] of Pointer;
  TCharSet       = set of char;

//For debugging and internal use, undocumented
function GetRefCnt(Source:AnsiString):Integer;
function ClrStringLocks:Boolean;

//Convert
function  IntToChr(const X:Integer):AnsiString;
function  ChrToInt(const Source:AnsiString):Integer;
function  WordToChr(const X:Word):AnsiString;
function  ChrToWord(const Source:AnsiString):Word;
function  SngToChr(const X:Single):AnsiString;
function  ChrToSng(const Source:AnsiString):Single;
function  DblToChr(var X:Double):AnsiString;
function  ChrToDbl(const Source:AnsiString):Double;
function  CurToChr(var X:Currency):AnsiString;
function  ChrToCur(const Source:AnsiString):Currency;
function  BinToInt(const Source:AnsiString):Integer;
function  IntToBin(const X:Integer):AnsiString;
function  HexToInt(const Source:AnsiString):Integer;
function  NumToWord(const Source:AnsiString;Money:Boolean):AnsiString;
function  OrdSuffix(const X:Integer):AnsiString;
function  SwapEndian(const X:Integer):Integer;
function  BoolToStr(const TF:Boolean):AnsiString;
function  RadixStr(const NumStr:AnsiString; Old,New:Integer):AnsiString;

//Search
function  ScanF(const Source,Search:AnsiString;Start:Integer):Integer;
function  ScanFF(const Source,Search:AnsiString;Start:Integer):Integer;
function  ScanR(const Source,Search:AnsiString;Start:Integer):Integer;
function  ScanRF(const Source,Search:AnsiString;Start:Integer):Integer;
function  ScanB(const Source:AnsiString;X:Char;Start:Integer):Integer;
function  ScanC(const Source:AnsiString;X:Char;Start:Integer):Integer;
function  ScanD(const Source,Search:AnsiString;Start:Integer):Integer;
function  ScanL(const Source:AnsiString;Start:Integer):Integer;
function  ScanU(const Source:AnsiString;Start:Integer):Integer;
function  ScanN(const Source:AnsiString;Start:Integer):Integer;
function  ScanCC(const Source:AnsiString;X:Char;Count:Integer):Integer;
function  ScanNC(const Source:AnsiString;X:Char):Integer;
function  ScanNB(const Source:AnsiString;X:Char):Integer;
function  ScanT(const Source,Table:AnsiString;Start:Integer):Integer;
function  ScanTQ(const Source,Table:AnsiString;Start:Integer):Integer;
function  ScanRT(const Source,Table:AnsiString;Start:Integer):Integer;
function  ScanNT(const Source,Table:AnsiString;Start:Integer):Integer;
function  ScanRNT(const Source,Table:AnsiString;Start:Integer):Integer;
function  ScanP(const Source,Search:AnsiString;var Start:Integer):Integer;
function  ScanW(const Source,Search:AnsiString;var Start:Integer):Integer;
function  ScanQ(const Source,Search:AnsiString;Start:Integer):Integer;
function  ScanQC(const Source,Search:AnsiString;Start:Integer):Integer;
function  ScanQR(const Source,Search:AnsiString;Start:Integer):Integer;
function  ScanQRC(const Source,Search:AnsiString;Start:Integer):Integer;
function  ScanZ(const Source,Search:AnsiString;Defects:Integer;var Start:Integer):Integer;
function  ScanSS(const Source,Search:AnsiString;const Start,Stop:Integer):Integer;
function  ScanSC(const Source,Search:AnsiString;const Start:Integer; const Stop:Char):Integer;
function  ScanLU(const Source:AnsiString;Lower,Upper:Char;Start:Integer):Integer;
function  ScanOR(const Source,Search:AnsiString;Start:Integer):Integer;
function  ScanBfr(const Bfr:PByte;Search:AnsiString;BfrLen:Integer):PByte;
function  ScanBfrC(const Bfr:PByte;Search:AnsiString;BfrLen:Integer):PByte;
function  ScanBfrR(const Bfr:PByte;Search:AnsiString;BfrLen:Integer):PByte;
function  ScanBfrRC(const Bfr:PByte;Search:AnsiString;BfrLen:Integer):PByte;
function  MakePattern( const Source:AnsiString) : AnsiString;
function  ScanRX( const Source,Pattern : AnsiString; var Start : integer ):Integer;
procedure SetQuotes(const QStart,QEnd:Char);
function  WScan(const Source,Search:WideString;Start:Integer):Integer;
function  WScanC(const Source:WideString;X:WideChar;Start:Integer):Integer;
function  WScanRC(const Source:WideString;X:WideChar;Start:Integer):Integer;

//Pad,Trim,Slice
function  LTrim(const Source:AnsiString;X:Char):AnsiString;
function  RTrim(const Source:AnsiString;X:Char):AnsiString;
function  CTrim(const Source:AnsiString;X:Char):AnsiString;
procedure LPad(var Source: AnsiString; const X:Char;Count:Integer);
procedure RPad(var Source: AnsiString; const X:Char;Count:Integer);
procedure CPad(var Source: AnsiString; const X:Char;Count:Integer);
function  LAdd(const Source: AnsiString; const X:Char;Count:Integer):AnsiString;
function  RAdd(const Source: AnsiString; const X:Char;Count:Integer):AnsiString;
function  CAdd(const Source: AnsiString; const X:Char;Count:Integer):AnsiString;
procedure LFlush(var Source: AnsiString);
procedure RFlush(var Source: AnsiString);
procedure CFlush(var Source: AnsiString);
function  LStr(const Source:AnsiString;Count:Integer):AnsiString;
function  RStr(const Source:AnsiString;Count:Integer):AnsiString;
function  CStr(const Source:AnsiString;Index,Count:Integer):AnsiString;
function  IStr(const Source:AnsiString;Index:Integer):AnsiString;
function  Extract(const Source,Srch:AnsiString;Index:Integer):AnsiString;

//Tokens
function  Parse(const Source,Table:AnsiString;var Index:Integer):AnsiString;
function  ParseWord(const Source,Table:AnsiString;var Index:Integer):AnsiString;
function  ParseTag(const Source,Start,Stop:AnsiString;var Index:Integer):AnsiString;
function  Fetch(const Source,Table:AnsiString;Num:Integer;DelFlg:Boolean):AnsiString;
function  GetDelimiter:Char;
function  SetDelimiter(Delimit:Char):Boolean;
function  GetDelimiter2:AnsiString;
function  SetDelimiter2(Delimit:AnsiString):Boolean;
function  InsertToken(var Source:AnsiString; const Token:AnsiString;Index:Integer):Boolean;
function  DeleteToken(var Source:AnsiString;var Index:Integer):Boolean;
function  ReplaceToken(var Source:AnsiString;Token:AnsiString;Index:Integer):Boolean;
function  GetToken(const Source:AnsiString;Index:Integer):AnsiString;
function  PrevToken(const Source:AnsiString;var Index:Integer):Boolean;
function  NextToken(const Source:AnsiString;var Index:Integer):Boolean;
function  GetTokenNum(const Source:AnsiString;Index:Integer):Integer;
function  GetTokenPos(const Source:AnsiString;Num:Integer):Integer;
function  GetTokenCnt(const Source:AnsiString):Integer;

//Match
function  Similar(const S1,S2:AnsiString):Integer;
function  StrDist(const S1,S2:AnsiString):Integer;
function  Soundex(const Source:AnsiString):Integer;
function  MetaPhone(const Name:AnsiString):Integer;

//Count
function  CountF(const Source:AnsiString;X:Char;Index:Integer):Integer;
function  CountR(const Source:AnsiString;X:Char;Index:Integer):Integer;
function  CountT(const Source,Table:AnsiString;Index:Integer):Integer;
function  CountM(const Source,Table:AnsiString;Index:Integer):Integer;
function  CountN(const Source,Table:AnsiString;Index:Integer):Integer;
function  CountW(const Source,Table:AnsiString):Integer;

//Test
function  IsNum(const Source:AnsiString):Boolean;
function  IsHex(const Source:AnsiString):Boolean;
function  IsFloat(const Source:AnsiString):Boolean;
function  IsAlpha(const Source:AnsiString):Boolean;
function  IsAlphaNum(const Source:AnsiString):Boolean;
function  IsMask(const Source,Mask:AnsiString;Index:Integer):Boolean;
function  IsNull(const Source:AnsiString):Boolean;
function  IsDateTime(const Source:AnsiString):Boolean;
function  IsTable(const Source,Table:AnsiString):Boolean;
function  IsField(const Source,Table:AnsiString;const Index,Cnt:Integer):Boolean;
function  IsSet(const Source:AnsiString;Multiple,Single:TCharSet):Boolean;
function  IsNumChar(const C:Char):Boolean;
function  IsAlphaChar(const C:Char):Boolean;
function  IsAlphaNumChar(const C:Char):Boolean;
function  IsLChar(C:Char):Boolean;
function  IsUChar(C:Char):Boolean;
function  IsCChar(C1,C2:Char):Boolean;
function  IsFound(const Source,Search:AnsiString;Start:Integer):Boolean;
function  IsMatch(const Source,Pattern:AnsiString;CaseFlg:Boolean):Boolean;
function  AnsiCompare(const S1,S2:AnsiString;I1,I2,Cnt:Integer):Integer;
function  HyperCompare(S1,S2:AnsiString;I1,I2,Cnt:Integer):Integer;
function  StringAt(const Src,Table:AnsiString;Index,Cnt:Integer):Boolean;

//Edit
function  MakeNum(var Source:AnsiString):Integer;
function  MakeHex(var Source:AnsiString):Integer;
function  MakeFloat(var Source:AnsiString):Integer;
function  MakeFixed(var Source:AnsiString; const Count:Byte):Integer;
function  MakeAlpha(var Source:AnsiString):Integer;
function  MakeAlphaNum(var Source:AnsiString):Integer;
function  MakeTime(var Source:AnsiString):Integer;
function  MakeTable(var Source:AnsiString;const Table:AnsiString):Integer;
function  IntToFmtStr(const X:Integer):AnsiString;
function  DupChr(const X:Char;Count:Integer):AnsiString;
function  UChar(const Source:Char):Char;
function  LChar(const Source:Char):Char;
function  RChar(const Source:Char):Char;
procedure UCase(var Source:AnsiString;Index,Count:Integer);
procedure LCase(var Source:AnsiString;Index,Count:Integer);
procedure AnsiUCase(var Source:AnsiString;const Index,Count:Integer);
procedure AnsiLCase(var Source:AnsiString;const Index,Count:Integer);
procedure ProperCase(var Source: AnsiString);
procedure MoveStr(const S:AnsiString;XS:Integer;var D:AnsiString;const XD,Cnt:Integer);
procedure ShiftStr(var S:AnsiString;Index,Count:Integer);
procedure FillStr(var Source:AnsiString;const Index:Integer;X:Char);
procedure FillCnt(var Source:AnsiString;const Index,Cnt:Integer;X:Char);
procedure LCompact(var Source:AnsiString);
function  Compact(var Source:AnsiString):Integer;
function  DeleteC(var Source:AnsiString;const X:Char):Integer;
function  DeleteD(var Source:AnsiString;const X:Char):Integer;
function  DeleteS(var Source:AnsiString;const Index,Count:Integer):Integer;
function  DeleteT(var Source:AnsiString;const Table:AnsiString):Integer;
function  DeleteTQ(var Source:AnsiString;const Table:AnsiString):Integer;
function  DeleteI(var Source:AnsiString;const Table:AnsiString; const Index:Integer):Integer;
function  DeleteNT(var Source:AnsiString;const Table:AnsiString):Integer;
function  DeleteNI(var Source:AnsiString;const Table:AnsiString; const Index:Integer):Integer;
procedure ReplaceC(var Source:AnsiString;const X,Y:Char);
procedure ReplaceT(var Source:AnsiString;const Table:AnsiString;X:Char);
procedure ReplaceI(var Source:AnsiString;const Table:AnsiString;Index:Integer;X:Char);
procedure ReplaceS(var Source:AnsiString;const Target,Replace:AnsiString);
function  ReplaceSC(var Source:AnsiString;const Target,Replace:AnsiString;CaseFlg:Boolean):Integer;
procedure OverWrite(var Source:AnsiString; const Replace:AnsiString;Index:Integer);
procedure Translate(var Source:AnsiString;const Table,Replace:AnsiString);
procedure RevStr(var Source:AnsiString);
procedure IncStr(var Source:AnsiString);
function  TruncPath(var S:AnsiString; const Count:Integer):Boolean;
function  Abbreviate(var S:AnsiString; const T:AnsiString;const Count:Integer):Boolean;
procedure TomCat(const S:AnsiString; var D:AnsiString; var InUse:Integer);
function  BuildTable(const Source:AnsiString):AnsiString;
procedure CharSort(var A:AnsiString);
function  WrapText(const Source:AnsiString;MaxWidth:Integer):AnsiString;
function  SetStrAddr(Addr:DWord):AnsiString;
function  SetCaseTable(const Lower,Upper:AnsiString):Boolean;

//Arrays
procedure StrSort(var A:array of AnsiString;const Cnt:Integer);
function  StrSrch(var A:array of AnsiString;const Target:AnsiString;Cnt:Integer):Integer;
function  StrDelete(var A:array of AnsiString;const Target,Cnt:Integer):Boolean;
function  StrInsert(var A:array of AnsiString;const Target,Cnt:Integer):Boolean;
procedure StrSwap(var S1,S2:AnsiString);
procedure ISortA(var A:array of integer;const Cnt:Integer);
procedure ISortD(var A:array of integer;const Cnt:Integer);
procedure HyperSort(const ArrayPtr:Pointer;const Cnt:Integer);
function  IntSrch(const A:array of Integer;const Target,Cnt:Integer):Integer;
function  IntDelete(var A:array of Integer; const Target,Cnt:Integer):Boolean;
function  IntInsert(var A:array of Integer; const Target,Cnt:Integer):Boolean;
procedure Dim(var P; const Size:Integer; Initialize:Boolean);
function  Cap(const P):Integer;

//Hash, Encrypt
function  Hash(const Source:AnsiString):Integer;
procedure EnCipher(var Source:AnsiString);
procedure DeCipher(var Source:AnsiString);
procedure Crypt(var Source:AnsiString; const Key:AnsiString);
procedure CryptBfr(const BfrPtr:Pointer; const Key:AnsiString; const BfrLen:Integer);
procedure IniRC4(const Key:AnsiString);
procedure CryptRC4(var Source:AnsiString);
function  HideInteger(const Value:Integer):AnsiString;
function  SeekInteger(const S:AnsiString):Integer;
function  Chaff(Source:AnsiString):AnsiString;
function  Winnow(Source:AnsiString):AnsiString;

//CRC, Checksum
function  ChkSum(const Source:AnsiString):Word;
procedure MakeSumZero(var Source:AnsiString);
function  ChkSumXY(const Source:AnsiString):Byte;
function  NetSum(const Source:AnsiString):Word;
function  CRC16(const IniCRC:Word;Source:AnsiString):Word;
function  CRCXY(const IniCRC:Word;Source:AnsiString):Word;
function  CRC32(const IniCRC:Integer;Source:AnsiString):Integer;
function  CRCBfr(const IniCRC:Integer; Bfr:PByte;BfrLen:Integer):Integer;
function  CreditSum(const Source:AnsiString):Integer;
function  ISBNSum(const Source:AnsiString):Boolean;
function  ValidSSN(Source:AnsiString):Integer;

//Base64
function  EnCodeInt(const X:Integer):AnsiString;
function  DeCodeInt(const Source:AnsiString):Integer;
function  EnCodeWord(const X:Word):AnsiString;
function  DeCodeWord(const Source:AnsiString):Word;
function  EnCodeSng(const X:Single):AnsiString;
function  DeCodeSng(const Source:AnsiString):Single;
function  EnCodeDbl(var X:Double):AnsiString;
function  DeCodeDbl(const Source:AnsiString):Double;
function  EnCodeCur(var X:Currency):AnsiString;
function  DeCodeCur(const Source:AnsiString):Currency;
function  EnCodeStr(const Source:AnsiString):AnsiString;
function  DeCodeStr(const Source:AnsiString):AnsiString;
function  URLEncode(S:AnsiString):AnsiString;
function  URLDecode(S:AnsiString):AnsiString;
function  UUEncode(S:AnsiString):AnsiString;
function  UUDecode(S:AnsiString):AnsiString;

//Math
function  EnCodeBCD(const Source:AnsiString):AnsiString;
function  DeCodeBCD(const Source:AnsiString):AnsiString;
function  AddUSI(const X,Y:Integer):Integer;
function  SubUSI(const X,Y:Integer):Integer;
function  MulUSI(const X,Y:Integer):Integer;
function  DivUSI(const X,Y:Integer):Integer;
function  ModUSI(const X,Y:Integer):Integer;
function  CmpUSI(const X,Y:Integer):Integer;
function  USIToStr(const X:Integer):AnsiString;
function  StrToUSI(const Source:AnsiString):Integer;
function  StrAdd(X,Y:AnsiString):AnsiString;
function  StrSub(X,Y:AnsiString):AnsiString;
function  StrMul(X,Y:AnsiString):AnsiString;
function  StrDiv(X,Y:AnsiString; var R:AnsiString):AnsiString;
function  StrCmp(X,Y:AnsiString):Integer;
function  StrAbs(X:AnsiString):AnsiString;
function  StrHex(X:AnsiString):AnsiString;
function  StrDec(X:AnsiString):AnsiString;
function  StrRnd(X:AnsiString; Digits:Integer):AnsiString;

//Integer Date/Time
function  TDT2IDT(const TDT:TDateTime):IDateTime; //TDateTime to IDateTime
function  IDT2TDT(const IDT:IDateTime):TDateTime; //IDateTime to TDateTime
function  StrToITime(const Source:AnsiString):IDateTime;  //String to ITime
function  StrToIDate(const Source:AnsiString):IDateTime;  //String to IDate
function  StrToIDateTime(const Source:AnsiString):IDateTime;  //String to IDate
function  IDateToStr(const IDT:IDateTime):AnsiString;
function  ITimeToStr(const IDT:IDateTime):AnsiString;
function  ITimeTo2460(IDT:IDateTime):AnsiString;
function  IDateTimeToStr(const IDT:IDateTime):AnsiString;
function  EncodeITime(const D,H,M,S:Word):IDateTime;
procedure DecodeITime(const IDT:IDateTime; var D,H,M:Word);
function  EncodeIDate(const Y,M,D:Word):IDateTime;
procedure DecodeIDate(const IDT:IDateTime; var Y,M,D:Word);
function  RoundITime(const IDT:IDateTime;Mns:Word):IDateTime;
function  WeekNum(const TDT:TDateTime; FirstDayofWeek:Integer):Word;
function  ISOWeekNum(const TDT:TDateTime):Word;
function  Easter(const Year:Word):Integer;
function  DayOfMonth(Year,Month,Day,N:Word):Word;
function  DayOfWk(Year,Month,Day:Word):Word;
function  FirstWeek:AnsiString;
function  FirstDay:AnsiString;
function  FormatToDateTime(S,Format:AnsiString):TDateTime;
function  IsDateValid(S,Format:AnsiString):Boolean;

//API
function  GetUser:AnsiString;
function  GetNetUser: AnsiString;
function  GetComputer:AnsiString;
function  GetLocalIP:AnsiString;
function  GetDrives:AnsiString;
function  RemoteDrive(const Drv:Char):Boolean;
function  GetDisk(const Drv:Char; var CSize,Available,Total:DWord):Boolean;
function  GetVolume(const Drv:Char; var Name,FSys:AnsiString; var S:DWord):Boolean;
function  GetWinDir:AnsiString;
function  GetSysDir:AnsiString;
function  GetTmpDir: AnsiString;
function  GetExeDir:Ansistring;
function  GetTmpFile(const Path,Prefix:AnsiString):AnsiString;
function  GetWinClass(const Title:AnsiString):AnsiString;
function  GetDOSName(const LongName:AnsiString):AnsiString;
function  GetWinName(const FileName:AnsiString):AnsiString;
function  GetCPU:AnsiString;
function  GetDefaultPrn:AnsiString;
function  GetPrinters:AnsiString;
function  GetDocType(fileExt:AnsiString):AnsiString;
procedure GetMemStatus(var RAMTotal,RAMUsed,PGTotal,PGUsed:Integer);
function  IsWinNT:Boolean;
function  IsNetWork:Boolean;
function  GetKeyValues(const Root:HKey;Key,Values:AnsiString):AnsiString;
procedure KillOLE;
function  GetProcID(const hWnd:THandle):THandle;
function  DOSExec(const CmdLine:AnsiString;const DisplayMode:Integer):Boolean;
function  WaitExec(const CmdLine:AnsiString;const DisplayMode:Integer):Integer;
procedure PipeExec(const CmdLine:AnsiString;const DisplayMode:Integer);
function  ReadPipe(var S:AnsiString):Integer;
function  WritePipe(const S:AnsiString):Integer;
procedure ClosePipe;
function  SetAppPriority(const Priority:DWord):Boolean;
function  GetFileDate(const FileName:AnsiString):AnsiString;
function  GetFreq:Comp;
function  GetCount:Comp;
function  SetClipText(const Source:AnsiString):Boolean;
function  GetClipText:AnsiString;
function  DriveReady(const Drive: Char): Boolean;
procedure StartSelect(const Key:Char);
function  ReBoot:Boolean;
function  GetBuildInfo(const Filename:AnsiString):AnsiString;
function  PathScan(const FileName:AnsiString; var Path:AnsiString):Boolean;
function  GetDomain:AnsiString;
function  GetRelativePath(Root,Dest:AnsiString;CaseFlg:Boolean):AnsiString;

//Compression
procedure IniRLE;
function  RLE(const Bfr:AnsiString; L:Word):AnsiString;
function  RLD(const Bfr:AnsiString; L:Word):AnsiString;