home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / mksmvp10.zip / MKSTRING.PAS < prev    next >
Pascal/Delphi Source File  |  1997-06-17  |  18KB  |  824 lines
  1. Unit MKString;
  2. {$I MKB.Def}
  3.  
  4. {
  5.      MKString - Copyright 1993 by Mark May - MK Software
  6.      You are free to use this code in your programs, however
  7.      it may not be included in Source/TPU function libraries
  8.      without my permission.
  9.  
  10.      Mythical Kingom Tech BBS (513)237-7737 HST/v32
  11.      FidoNet: 1:110/290
  12.      Rime: ->MYTHKING
  13.      You may also reach me at maym@dmapub.dma.org
  14. }
  15.  
  16.  
  17.  
  18.  
  19. Interface
  20.  
  21. {$IFDEF WINDOWS}
  22. Uses WinDos;
  23. {$ELSE}
  24. Uses Dos, Use32;
  25. {$ENDIF}
  26.  
  27. Procedure MKStrCat(Var St: String; AStr: String);
  28. Function LoCase(Ch: Char): Char;
  29. Function padright(st:string;ch:char;l:integer):string;
  30. Function PadLeft(St:String;Ch:Char;L:Integer): String;
  31. function striplead(st:string;ch:char):string;
  32. Function StripTrail(St:String;Ch:Char):String;
  33. Function StripBoth(St:String;Ch:Char):String;
  34. Function Upper(St:String):String;
  35. Function Lower(St:String):String;
  36. Function Proper(St:String):String;
  37. Function WWrap(St:String; Max:Byte):String;
  38. function ExtractWord(Str : String; N : Integer) : String;
  39. Function WordCount(Str : String) : Integer;
  40. Function CommaStr(Number: LongInt): String;
  41. Function Long2Str(Number: LongInt): String;
  42. Function Bin2Str(Number: Byte): String;
  43. Function Str2Bin(St: String): Byte;
  44. Function Str2Long(St: String): LongInt;
  45. Function HexLong(Number:LongInt): String;
  46. Function HexStr(Number: Word): String;
  47. Function HexByte(Number: Byte): String;
  48. Function DateStr(DosDate: LongInt): String;
  49. Function TimeStr(DosDate: LongInt): String;
  50. Procedure AddBackSlash(Var InPath: String);
  51. Function WithBackSlash(InPath: String): String;
  52. {$IFDEF WINDOWS}
  53. Function FormattedDate(DT: TDateTime; Mask: String): String;
  54. {$ELSE}
  55. Function FormattedDate(DT: DateTime; Mask: String): String;
  56. {$ENDIF}
  57. Function FormattedDosDate(DosDate: LongInt; Mask:String): String;
  58. Function DOWStr(Dow: Word): String;
  59. Function DOWShortStr(DOW: Word): String;
  60. Function ReformatDate(ODate: String; Mask: String): String;
  61. Function LongDate(DStr: String): LongInt;
  62. Function TimeStr2Word(TS: String): Word;
  63. Function Word2TimeStr(CTime: Word): String;
  64. Function MonthStr(MonthNo: Word): String;
  65. Function Az2Str(Var Str: String; MaxLen: Byte): String; {Convert asciiz to string}
  66. Procedure Str2Az(Str: String; MaxLen: Byte; Var AZStr); {Convert string to asciiz}
  67. Function MKDateToStr(MKD: String): String; {Convert YYMMDD to MM-DD-YY}
  68. Function StrToMKDate(Str: String): String; {Convert MM-DD-YY to YYMMDD}
  69. Function CleanChar(InChar: Char): Char;
  70. Function IsNumeric(Str: String): Boolean;
  71. Function PosLastChar(Ch: Char; St: String): Word;
  72.  
  73.  
  74. Const
  75.   CommaChar: Char = ',';
  76.  
  77. Var
  78.   ExtraString: String;
  79.  
  80. Implementation
  81.  
  82.  
  83. Function LoCase(Ch: Char): Char;
  84.   Begin
  85.   If (Ch in ['A'..'Z']) Then
  86.     LoCase := Chr(Ord(Ch) + 32)
  87.   Else
  88.     LoCase := Ch;
  89.   End;
  90.  
  91.  
  92. Procedure AddBackSlash(Var InPath: String);
  93.   Begin
  94.   If Length(InPath) > 0 Then
  95.     Begin
  96.     If InPath[Length(InPath)] <> '\' Then
  97.       Begin
  98.       InPath[0] := Chr(Length(InPath) + 1);
  99.       InPath[Length(InPath)] := '\';
  100.       End;
  101.     End;
  102.   End;
  103.  
  104.  
  105. Function WithBackSlash(InPath: String): String;
  106.   Begin
  107.   AddBackSlash(InPath);
  108.   WithBackSlash := InPath;
  109.   End;
  110.  
  111.  
  112. Function Bin2Str(Number: Byte): String;
  113.   Var
  114.     Temp1: Byte;
  115.     Temp2: Byte;
  116.     i: Word;
  117.     TempStr: String[8];
  118.  
  119.   Begin
  120.   Temp1 := 0;
  121.   Temp2 := $80;
  122.   For i := 1 to 8 Do
  123.     Begin
  124.     If (Number and Temp2) <> 0 Then
  125.       TempStr[i] := '1'
  126.     Else
  127.       TempStr[i] := '0';
  128.     Temp2 := Temp2 shr 1;
  129.     End;
  130.   TempStr[0] := #8;
  131.   Bin2Str := TempStr;
  132.   End;
  133.  
  134.  
  135. Function Str2Bin(St: String): Byte;
  136.   Var
  137.     i: Word;
  138.     Temp1: Byte;
  139.     Temp2: Byte;
  140.  
  141.   Begin
  142.   St := StripBoth(St,' ');
  143.   St := PadLeft(St,'0',8);
  144.   Temp1 := 0;
  145.   Temp2 := $80;
  146.   For i := 1 to 8 Do
  147.     Begin
  148.     If St[i] = '1' Then
  149.       Inc(Temp1,Temp2);
  150.     Temp2 := Temp2 shr 1;
  151.     End;
  152.   Str2Bin := Temp1;
  153.   End;
  154.  
  155.  
  156. Function Str2Long(St: String): LongInt;
  157.   Var
  158.    i: Word;
  159.    Temp: LongInt;
  160.  
  161.   Begin
  162.   St := StripBoth(St,' ');
  163.   Val(St,Temp,i);
  164.   If i = 0 Then
  165.     Str2Long := Temp
  166.   Else
  167.     Str2Long := 0;
  168.   End;
  169.  
  170.  
  171. Function DateStr(DosDate: LongInt): String;
  172.   Var
  173. {$IFDEF WINDOWS}
  174.     DT:TDateTime;
  175. {$ELSE}
  176.     DT: DateTime;
  177. {$ENDIF}
  178.     OutStr: String[8];
  179.     TempStr: String[8];
  180.  
  181.   Begin
  182.     UnPackTime(DosDate,DT);
  183.     Str(DT.Month:2,TempStr);
  184.     If TempStr[1] = ' ' Then
  185.       OutStr[1] := '0'
  186.     Else
  187.       OutStr[1] := TempStr[1];
  188.     OutStr[2] := TempStr[2];
  189.     OutStr[3] := '-';
  190.     Str(DT.Day:2,TempStr);
  191.     If TempStr[1] = ' ' Then
  192.       OutStr[4] := '0'
  193.     Else
  194.       OutStr[4] := TempStr[1];
  195.     OutStr[5] := TempStr[2];
  196.     OutStr[6] := '-';
  197.     Str(DT.Year:4,TempStr);
  198.     If TempStr[3] = ' ' Then
  199.       OutStr[7] := '0'
  200.     Else
  201.       OutStr[7] := TempStr[3];
  202.     OutStr[8] := TempStr[4];
  203.     OutStr[0] := #8;
  204.     DateStr := OutStr;
  205.   End;
  206.  
  207. Function TimeStr(DosDate: LongInt): String;
  208.   Var
  209. {$IFDEF WINDOWS}
  210.     DT: TDateTime;
  211. {$ELSE}
  212.     DT: DateTime;
  213. {$ENDIF}
  214.     OutStr: String[8];
  215.     TempStr: String[8];
  216.  
  217.   Begin
  218.     UnPackTime(DosDate,DT);
  219.     Str(DT.Hour:2,TempStr);
  220.     If TempStr[1] = ' ' Then
  221.       OutStr[1] := '0'
  222.     Else
  223.       OutStr[1] := TempStr[1];
  224.     OutStr[2] := TempStr[2];
  225.     OutStr[3] := ':';
  226.     Str(DT.Min:2,TempStr);
  227.     If TempStr[1] = ' ' Then
  228.       OutStr[4] := '0'
  229.     Else
  230.       OutStr[4] := TempStr[1];
  231.     OutStr[5] := TempStr[2];
  232.     OutStr[6] := ':';
  233.     Str(DT.Sec:2,TempStr);
  234.     If TempStr[1] = ' ' Then
  235.       OutStr[7] := '0'
  236.     Else
  237.       OutStr[7] := TempStr[1];
  238.     OutStr[8] := TempStr[2];
  239.     OutStr[0] := #8;
  240.     TimeStr := OutStr;
  241.   End;
  242.  
  243.  
  244. Function HexByte(Number: Byte): String;
  245.   Var
  246.     HChar: Char;
  247.     LChar: Char;
  248.  
  249.   Begin
  250.   LChar := Chr((Number And $F) + 48);
  251.   If LChar > '9' Then
  252.     LChar := Chr(Ord(LChar) + 7);
  253.   HChar := Chr((Number shr 4) + 48);
  254.   If HChar > '9' Then
  255.     HChar := Chr(Ord(HChar) + 7);
  256.   HexByte := HChar + LChar;
  257.   End;
  258.  
  259.  
  260. Function HexStr(Number: Word): String;
  261.   Begin
  262.   HexStr := HexByte(Number Shr 8) + HexByte(Number And $FF);
  263.   End;
  264.  
  265.  
  266. Function HexLong(Number: LongInt): String;
  267.   Type
  268.     WordRec = Record
  269.       Lo: Word;
  270.       Hi: Word;
  271.     End;
  272.  
  273.   Begin
  274.   HexLong := HexStr(WordRec(Number).Hi) + HexStr(WordRec(Number).Lo);
  275.   End;
  276.  
  277.  
  278. Function Long2Str(Number: LongInt): String;
  279.   Var
  280.     TempStr: String;
  281.  
  282.   Begin
  283.   Str(Number,TempStr);
  284.   Long2Str := TempStr;
  285.   End;
  286.  
  287.  
  288. Function CommaStr(Number: LongInt): String;
  289.   Var
  290.     StrPos: Integer;
  291.     NumberStr: String;
  292.  
  293.   Begin
  294.   NumberStr := Long2Str(Number);
  295.   StrPos := Length(NumberStr) - 2;
  296.   While StrPos > 1 Do
  297.     Begin
  298.     Insert(',',NumberStr,StrPos);
  299.     StrPos := StrPos - 3;
  300.     End;
  301.   CommaStr := NumberStr;
  302.   End;
  303.  
  304.  
  305.  
  306.  
  307.  
  308. Function wordcount(str : string) : integer;
  309.  
  310.   var
  311.     count : integer;
  312.     i : integer;
  313.     len : integer;
  314.  
  315.   begin
  316.   len := length(str);
  317.   count := 0;
  318.   i := 1;
  319.   while i <= len do
  320.     begin
  321.     while ((i <= len) and ((str[i] = #32) or (str[i] = #9) or (Str[i] = ';'))) do
  322.       inc(i);
  323.     if i <= len then
  324.       inc(count);
  325.     while ((i <= len) and ((str[i] <> #32) and (str[i] <> #9) and (Str[i] <> ';'))) do
  326.       inc(i);
  327.     end;
  328.   wordcount := count;
  329.   end;
  330.  
  331.  
  332. function extractword(str : string; n : integer) : string;
  333.   Var
  334.     count : integer;
  335.     i : integer;
  336.     len : integer;
  337.     done : boolean;
  338.     retstr : string;
  339.  
  340.   Begin
  341.   retstr := '';
  342.   len := length(str);
  343.   count := 0;
  344.   i := 1;
  345.   done := false;
  346.   While (i <= len) and (not done) do
  347.     Begin
  348.     While ((i <= len) and ((str[i] = #32) or (str[i] = #9) or (Str[i] = ';'))) do
  349.       inc(i);
  350.     if i <= len then
  351.       inc(count);
  352.     if count = n then
  353.       begin
  354.       retstr[0] := #0;
  355.       If (i > 1) Then
  356.         If Str[i-1] = ';' Then
  357.           RetStr := ';';
  358.       while ((i <= len) and ((str[i] <> #32) and (str[i] <> #9) and (Str[i] <> ';'))) do
  359.         begin
  360.         inc(retstr[0]);
  361.         retstr[ord(retstr[0])] := str[i];
  362.         inc(i);
  363.         end;
  364.       done := true;
  365.       end
  366.     Else
  367.       while ((i <= len) and ((str[i] <> #32) and (str[i] <> #9) and (Str[i] <> ';'))) do
  368.         inc(i);
  369.     End;
  370.   extractword := retstr;
  371.   End;
  372.  
  373.  
  374. Function WWrap(St:String; Max:Byte):String;
  375.   Var
  376.     TempStr: String;
  377.     TempPos: Byte;
  378.  
  379.   Begin
  380.   ExtraString := '';
  381.   TempStr := St;
  382.   If Length(TempStr) > Max Then
  383.     Begin
  384.     TempPos := Max;
  385.     While ((TempStr[TempPos] <> ' ') And (TempPos > (Max - 20))
  386.       And (TempPos > 1)) Do
  387.       Dec(TempPos);
  388.     If (Length(TempStr) > TempPos) Then
  389.       ExtraString := Copy(TempStr,TempPos + 1,Length(TempStr) - TempPos);
  390.     TempStr[0] := Chr(TempPos);
  391.     End;
  392.   WWrap := TempStr;
  393.   End;
  394.  
  395.  
  396. Function Proper(St:String):String;
  397.   Var
  398.     TempStr: String;
  399.     i: Integer;
  400.     NextUp: Boolean;
  401.  
  402.   Begin
  403.   If Length(St) = 0 Then
  404.     Proper := ''
  405.   Else
  406.     Begin
  407.     i := 1;
  408.     NextUp := True;
  409.     TempStr := St;
  410.     While i <= Length(TempStr) Do
  411.       Begin
  412.       If ((TempStr[i] < 'A') Or (TempStr[i] > 'z')
  413.         Or ((TempStr[i] > 'Z') And (TempStr[i] < 'a')) ) Then
  414.         Begin
  415.         NextUp := True;
  416.         End
  417.       Else
  418.         Begin
  419.         If NextUp = True Then
  420.           Begin
  421.           NextUp := False;
  422.           TempStr[i] := UpCase(TempStr[i]);
  423.           End
  424.         Else
  425.           Begin
  426.           If TempStr[i] < 'a' Then
  427.             TempStr[i] := Char(Ord(TempStr[i]) + 32);
  428.           End;
  429.         End;
  430.       i := i + 1;
  431.       End;
  432.     Proper := TempStr;
  433.     End;
  434.   End;
  435.  
  436.  
  437. Function PadLeft(St:String;Ch:Char;L:Integer): String;
  438.   Var
  439.     TempStr: String;
  440.     i: Word;
  441.  
  442.   Begin
  443.   If Length(St) >= L Then
  444.     PadLeft := Copy(St,1,L)
  445.   Else
  446.     Begin
  447.     For i := 1 to (L - Length(St)) Do
  448.       TempStr[i] := Ch;
  449.     TempStr[0] := Chr(L - Length(St));
  450.     PadLeft := TempStr + St;
  451.     End;
  452.   End;
  453.  
  454.  
  455. Function padright(st:string;ch:char;l:integer):string;
  456.  
  457.   var
  458.     i:          integer;
  459.     tempstr:    string;
  460.  
  461.   begin
  462.   tempstr := st;
  463.   if length(tempstr) > l then
  464.     tempstr[0] := chr(l);
  465.   if length(tempstr) < l then
  466.     begin
  467.     for i := length(tempstr)+1 to l do
  468.       tempstr[i] := ch;
  469.     tempstr[0] := chr(l);
  470.     end;
  471.   padright := tempstr;
  472.   end;
  473.  
  474.  
  475. Function Upper(St:String):String;
  476.   Var
  477.     TempStr: String;
  478.     i: Integer;
  479.  
  480.   Begin
  481.   i := 1;
  482.   TempStr := St;
  483.   While i <= Length(TempStr) Do
  484.     Begin
  485.     TempStr[i] := UpCase(TempStr[i]);
  486.     i := i + 1;
  487.     End;
  488.   Upper := TempStr;
  489.   End;
  490.  
  491.  
  492. Function Lower(St:String):String;
  493.   Var
  494.     TempStr: String;
  495.     i: Integer;
  496.  
  497.   Begin
  498.   i := 1;
  499.   TempStr := St;
  500.   While i <= Length(TempStr) Do
  501.     Begin
  502.     TempStr[i] := LoCase(TempStr[i]);
  503.     i := i + 1;
  504.     End;
  505.   Lower := TempStr;
  506.   End;
  507.  
  508.  
  509. function striplead(st:string;ch:char):string;
  510.   var
  511.     tempstr:        string;
  512.  
  513.   begin
  514.   tempstr := st;
  515.   While ((TempStr[1] = Ch) and (Length(TempStr) > 0)) do
  516.     tempstr := copy (tempstr,2,length(tempstr));
  517.   striplead := tempstr;
  518.   end;
  519.  
  520.  
  521. Function StripTrail(St:String;Ch:Char):String;
  522.   Var
  523.     TempStr: String;
  524.     i: Integer;
  525.  
  526.   Begin
  527.   TempStr := St;
  528.   i := Length(St);
  529.   While ((i > 0) and (St[i] = Ch)) Do
  530.     i := i - 1;
  531.   TempStr[0] := Chr(i);
  532.   StripTrail := TempStr;
  533.   End;
  534.  
  535.  
  536. Function StripBoth(St:String;Ch:Char):String;
  537.  
  538.   Begin
  539.   StripBoth := StripTrail(StripLead(St,Ch),Ch);
  540.   End;
  541.  
  542.  
  543. {$IFDEF WINDOWS}
  544. Function FormattedDate(DT: TDateTime; Mask: String): String;
  545. {$ELSE}
  546. Function FormattedDate(DT: DateTime; Mask: String): String;
  547. {$ENDIF}
  548.   Var
  549.     DStr: String[2];
  550.     MStr: String[2];
  551.     MNStr: String[3];
  552.     YStr: String[4];
  553.     HourStr: String[2];
  554.     MinStr: String[2];
  555.     SecStr: String[2];
  556.     TmpStr: String;
  557.     CurrPos: Word;
  558.     i: Word;
  559.  
  560.   Begin
  561.   TmpStr := Mask;
  562.   Mask := Upper(Mask);
  563.   DStr := Copy(PadLeft(Long2Str(Dt.Day),'0',2),1,2);
  564.   MStr := Copy(PadLeft(Long2Str(Dt.Month),'0',2),1,2);
  565.   YStr := Copy(PadLeft(Long2Str(Dt.Year),'0',4),1,4);
  566.   HourStr := Copy(PadLeft(Long2Str(Dt.Hour),' ', 2),1,2);
  567.   MinStr := Copy(PadLeft(Long2Str(Dt.Min), '0',2),1,2);
  568.   SecStr := Copy(PadLeft(Long2Str(Dt.Sec), '0',2),1,2);
  569.   MNStr := MonthStr(Dt.Month);
  570.   If (Pos('YYYY', Mask) = 0) Then
  571.     YStr := Copy(YStr,3,2);
  572.   CurrPos := Pos('DD', Mask);
  573.   If CurrPos > 0 Then
  574.     For i := 1 to Length(DStr) Do
  575.       TmpStr[CurrPos + i - 1] := DStr[i];
  576.   CurrPos := Pos('YY', Mask);
  577.   If CurrPos > 0 Then
  578.     For i := 1 to Length(YStr) Do
  579.       TmpStr[CurrPos + i - 1] := YStr[i];
  580.   CurrPos := Pos('MM', Mask);
  581.   If CurrPos > 0 Then
  582.     For i := 1 to Length(MStr) Do
  583.       TmpStr[CurrPos + i - 1] := MStr[i];
  584.   CurrPos := Pos('HH', Mask);
  585.   If CurrPos > 0 Then
  586.     For i := 1 to Length(HourStr) Do
  587.       TmpStr[CurrPos + i - 1] := HourStr[i];
  588.   CurrPos := Pos('SS', Mask);
  589.   If CurrPos > 0 Then
  590.     For i := 1 to Length(SecStr) Do
  591.       TmpStr[CurrPos + i - 1] := SecStr[i];
  592.   CurrPos := Pos('II', Mask);
  593.   If CurrPos > 0 Then
  594.     For i := 1 to Length(MinStr) Do
  595.       TmpStr[CurrPos + i - 1] := MinStr[i];
  596.   CurrPos := Pos('NNN', Mask);
  597.   If CurrPos > 0 Then
  598.     For i := 1 to Length(MNStr) Do
  599.       TmpStr[CurrPos + i - 1] := MNStr[i];
  600.   FormattedDate := TmpStr;
  601.   End;
  602.  
  603.  
  604. Function FormattedDosDate(DosDate: LongInt; Mask:String): String;
  605.   Var
  606.     {$IFDEF WINDOWS}
  607.     DT: TDateTime;
  608.     {$ELSE}
  609.     DT: DateTime;
  610.     {$ENDIF}
  611.  
  612.   Begin
  613.   UnPackTime(DosDate, DT);
  614.   FormattedDosDate := FormattedDate(DT, Mask);
  615.   End;
  616.  
  617.  
  618. Function DOWStr(Dow: Word): String;
  619.   Begin
  620.   Case DOW Of
  621.     0: DOWStr := 'Sunday';
  622.     1: DOWStr := 'Monday';
  623.     2: DOWStr := 'Tuesday';
  624.     3: DOWStr := 'Wednesday';
  625.     4: DOWStr := 'Thursday';
  626.     5: DOWStr := 'Friday';
  627.     6: DOWStr := 'Saturday';
  628.     Else
  629.       DOWStr := '?????';
  630.     End;
  631.   End;
  632.  
  633.  
  634. Function DOWShortStr(DOW: Word): String;
  635.   Begin
  636.   DOWShortStr := Copy(DOWStr(Dow),1,3);
  637.   End;
  638.  
  639.  
  640. Function ReformatDate(ODate: String; Mask: String): String;
  641.   Var
  642.     Code: Word;
  643.     {$IFDEF WINDOWS}
  644.     DT: TDateTime;
  645.     {$ELSE}
  646.     DT: DateTime;
  647.     {$ENDIF}
  648.  
  649.   Begin
  650.   Val(Copy(ODate,7,2), DT.Year, Code);
  651.   Val(Copy(ODate,1,2), DT.Month, Code);
  652.   Val(Copy(ODate,4,2), DT.Day, Code);
  653.   If DT.Year < 80 Then
  654.     Inc(DT.Year, 2000)
  655.   Else
  656.     Inc(DT.Year, 1900);
  657.   ReformatDate := FormattedDate(DT, Mask);
  658.   End;
  659.  
  660.  
  661. Function Word2TimeStr(CTime: Word): String;
  662.   Begin
  663.   Word2TimeStr := PadLeft(Long2Str(Hi(CTime)),'0',2) + ':' +
  664.     PadLeft(Long2Str(Lo(CTime)),'0',2);
  665.   End;
  666.  
  667.  
  668. Function TimeStr2Word(TS: String): Word;
  669.   Var
  670.     Vr: Word;
  671.     Vr2: Word;
  672.     Code: Word;
  673.  
  674.   Begin
  675.   Val(Copy(TS,1,2), Vr, Code);
  676.   Val(Copy(TS,4,2), Vr2, Code);
  677.   TimeStr2Word := Vr2 + (Vr shl 8);
  678.   End;
  679.  
  680.  
  681. Function MonthStr(MonthNo: Word): String;
  682.   Begin
  683.   Case MonthNo of
  684.     01: MonthStr := 'Jan';
  685.     02: MonthStr := 'Feb';
  686.     03: MonthStr := 'Mar';
  687.     04: MonthStr := 'Apr';
  688.     05: MonthStr := 'May';
  689.     06: MonthStr := 'Jun';
  690.     07: MonthStr := 'Jul';
  691.     08: MonthStr := 'Aug';
  692.     09: MonthStr := 'Sep';
  693.     10: MonthStr := 'Oct';
  694.     11: MonthStr := 'Nov';
  695.     12: MonthStr := 'Dec';
  696.     Else
  697.       MonthStr := '???';
  698.     End;
  699.   End;
  700.  
  701.  
  702. Function Az2Str(Var Str: String; MaxLen: Byte): String; {Convert asciiz to string}
  703.   Var
  704.     i: Word;
  705.     TmpStr: String;
  706.  
  707.   Begin
  708.   Move(Str, TmpStr[1], MaxLen);
  709.   TmpStr[0] := Chr(MaxLen);
  710.   i := Pos(#0, TmpStr);
  711.   If i > 0 Then
  712.     TmpStr[0] := Chr(i - 1);
  713.   Az2Str := TmpStr;
  714.   End;
  715.  
  716.  
  717. Procedure Str2Az(Str: String; MaxLen: Byte; Var AZStr); {Convert string to asciiz}
  718.   Begin
  719.   If Length(Str) >= MaxLen Then
  720.     Begin
  721.     Str[MaxLen] := #0;
  722.     Move(Str[1], AZStr, MaxLen);
  723.     End
  724.   Else
  725.     Begin
  726.     Str[Length(Str) + 1] := #0;
  727.     Move(Str[1], AZStr, Length(Str) + 1);
  728.     End;
  729.   End;
  730.  
  731.  
  732. Function MKDateToStr(MKD: String): String; {Convert YYMMDD to MM-DD-YY}
  733.   Begin
  734.   MKDateToStr := Copy(MKD,3,2) + '-' + Copy(MKD,5,2) + '-' +
  735.     Copy(MKD,1,2);
  736.   End;
  737.  
  738.  
  739. Function StrToMKDate(Str: String): String; {Convert MM-DD-YY to YYMMDD}
  740.   Begin
  741.   StrToMKDate := Copy(Str,7,2) + Copy(Str,1,2) + Copy(Str,4,2);
  742.   End;
  743.  
  744.  
  745. Function CleanChar(InChar: Char): Char;
  746.   Const
  747.     CtlChars: String[32] = 'oooooooooXoollo><|!Pg*|^v><-^v';
  748.     HiChars: String[64] = 'CueaaaageeeiiiAAEaaooouuyOUcLYPfarounNao?--//!<>***|||||||||||||';
  749.     HiChars2: String[64]= '|--|-+||||=+|=++-=--==-||||*****abcnEduto0nd80En=+><fj/~oo.vn2* ';
  750.  
  751.   Begin
  752.   Case InChar of
  753.     #0..#31: CleanChar := CtlChars[Ord(InChar) + 1];
  754.     #128..#191: CleanChar := HiChars[Ord(InChar) - 127];
  755.     #192..#255: CleanChar := HiChars2[Ord(InChar) - 191];
  756.     Else
  757.       CleanChar := InChar;
  758.     End;
  759.   End;
  760.  
  761.  
  762. Function IsNumeric(Str: String): Boolean;
  763.   Var
  764.     i: Word;
  765.  
  766.   Begin
  767.   IsNumeric := True;
  768.   For i := 1 To Length(Str) Do
  769.     If Not (Str[i] in ['0'..'9']) Then
  770.       IsNumeric := False;
  771.   End;
  772.  
  773.  
  774. Function LongDate(DStr: String): LongInt;
  775.   Var
  776.     {$IFDEF WINDOWS}
  777.     DT: TDateTime;
  778.     {$ELSE}
  779.     DT: DateTime;
  780.     {$ENDIF}
  781.     DosDate: LongInt;
  782.  
  783.   Begin
  784.   DT.Year := Str2Long(Copy(DStr,7,2));
  785.   If Dt.Year < 80 Then
  786.     Inc(DT.Year, 2000)
  787.   Else
  788.     Inc(DT.Year, 1900);
  789.   DT.Month := Str2Long(Copy(DStr,1,2));
  790.   DT.Day := Str2Long(Copy(DStr,4,2));
  791.   DT.Hour := 0;
  792.   DT.Min := 0;
  793.   DT.Sec := 0;
  794.   PackTime(DT, DosDate);
  795.   LongDate := DosDate;
  796.   End;
  797.  
  798.  
  799. Procedure MKStrCat(Var St: String; AStr: String);
  800.   Var
  801.     i: Word;
  802.  
  803.   Begin
  804.   i := Length(AStr);
  805.   If i + Length(St) > 255 Then
  806.     i := 255 - Length(St);
  807.   Move(AStr[1], St[Length(St) + 1], i);
  808.   Inc(St[0], i);
  809.   End;
  810.  
  811.  
  812. Function PosLastChar(Ch: Char; St: String): Word;
  813.   Var
  814.     i: Word;
  815.  
  816.   Begin
  817.   i := Length(St);
  818.   While ((i > 0) and (st[i] <> ch)) Do
  819.     Dec(i);
  820.   PosLastChar := i;
  821.   End;
  822.  
  823. End.
  824.