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