开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Delphi控件源码 > 查看源码
NMUUEncode.pas
资源名称：FastNet.rar　[点击查看]
上传用户：szzdds
上传日期：2013-09-18
资源大小：293k
文件大小：7k
源码类别：

Delphi控件源码

开发平台：

Delphi

NMUUEncode.pas：源码内容
  1. unit NMUUEncode;
  3. interface
  4. uses
  5.   Classes;
  7. function UUEEncode(const source, destination: TStream): Boolean;
  9. implementation
  10. uses
  11.   NMFileBuffer;
  13. function UUEEncode(const source, destination: TStream): Boolean;
  15.   function EncodeAByte(c: Byte): Byte;
  16.   begin
  17.     if c > 0 then
  18.       Result := (c and $3F) + $20
  19.     else
  20.       Result := Ord('`');
  21.   end;
  23. const
  24.   CRLF = #13#10;
  25.   ENCODELINELENGTH = 45;
  26.   EOB = #0;
  27.   INVALID = $00;
  28. var
  29.   TotalBytes: Integer;
  30.   index: Integer;
  32.   Output: string;
  33.   line_index: Integer;
  34.   LinePtr: PChar;
  35.   Len: Integer;
  36.   Len1: Integer;
  37.   OutputLength: Integer;
  39.   Char1: Byte;
  40.   Char2: Byte;
  41.   Char3: Byte;
  43.   OutChar1: Byte;
  44.   OutChar2: Byte;
  45.   OutChar3: Byte;
  46.   OutChar4: Byte;
  48.   InputPtr: PChar;
  49.   BufferEnd: PChar;
  50.   MemStuff: TNMFileBuffer;
  52.   Process: Boolean;
  54. begin
  55.   Process := True;
  57.   destination.Seek(0, soFromEnd);
  59.   TotalBytes := source.Size;
  60.   index := 0;
  62.   Char1 := 0;
  63.   Char2 := 0;
  64.   Char3 := 0;
  66.   Output := '';
  67.   OutputLength := ENCODELINELENGTH div 3 * 4;
  69.   MemStuff := TNMFileBuffer.Create(source);
  70.   try
  71.     InputPtr := MemStuff.BufPos;
  72.     BufferEnd := MemStuff.BufEnd;
  73.     while Process do
  74.     begin
  75.       line_index := 0;
  77.       if ((TotalBytes - index) >= ENCODELINELENGTH) then
  78.       begin
  79.             // Output the number of bytes in this line
  80.         SetLength(Output, OutputLength + 1);
  81.         LinePtr := PChar(Output);
  82.         OutChar1 := EncodeAByte(ENCODELINELENGTH);
  83.         LinePtr^ := Chr(OutChar1);
  84.         inc(LinePtr);
  86.         while (line_index < ENCODELINELENGTH) do
  87.         begin
  88.           if InputPtr >= BufferEnd then
  89.             if not MemStuff.NextMemoryBuffer(InputPtr, 0) then
  90.               Break
  91.             else
  92.             begin
  93.               InputPtr := MemStuff.BufPos;
  94.               BufferEnd := MemStuff.BufEnd;
  95.             end;
  96.           Char1 := Byte(InputPtr^);
  97.           inc(InputPtr);
  98.           inc(line_index);
  99.           inc(index);
  101.           if InputPtr >= BufferEnd then
  102.             if not MemStuff.NextMemoryBuffer(InputPtr, 0) then
  103.               Break
  104.             else
  105.             begin
  106.               InputPtr := MemStuff.BufPos;
  107.               BufferEnd := MemStuff.BufEnd;
  108.             end;
  109.           Char2 := Byte(InputPtr^);
  110.           inc(InputPtr);
  111.           inc(line_index);
  112.           inc(index);
  114.           if InputPtr >= BufferEnd then
  115.             if not MemStuff.NextMemoryBuffer(InputPtr, 0) then
  116.               Break
  117.             else
  118.             begin
  119.               InputPtr := MemStuff.BufPos;
  120.               BufferEnd := MemStuff.BufEnd;
  121.             end;
  122.           Char3 := Byte(InputPtr^);
  123.           inc(InputPtr);
  124.           inc(line_index);
  125.           inc(index);
  127.           OutChar1 := Char1 shr 2;
  128.           OutChar2 := (((Char1 shl 4) and $30) or ((Char2 shr 4) and $0F));
  129.           OutChar3 := (((Char2 shl 2) and $3C) or ((Char3 shr 6) and $03));
  130.           OutChar4 := Char3 and $3F;
  132.           OutChar1 := EncodeAByte(OutChar1);
  133.           OutChar2 := EncodeAByte(OutChar2);
  134.           OutChar3 := EncodeAByte(OutChar3);
  135.           OutChar4 := EncodeAByte(OutChar4);
  137.           LinePtr^ := Chr(OutChar1);
  138.           inc(LinePtr);
  139.           LinePtr^ := Chr(OutChar2);
  140.           inc(LinePtr);
  141.           LinePtr^ := Chr(OutChar3);
  142.           inc(LinePtr);
  143.           LinePtr^ := Chr(OutChar4);
  144.           inc(LinePtr);
  145.         end;
  146.         if InputPtr >= BufferEnd then
  147.           if not MemStuff.NextMemoryBuffer(InputPtr, 0) then
  148.             Break
  149.           else
  150.           begin
  151.             InputPtr := MemStuff.BufPos;
  152.             BufferEnd := MemStuff.BufEnd;
  153.           end;
  154.       end
  155.       else
  156.       begin
  157.         Len := TotalBytes - index; // get bytes left over
  158.         Len1 := Len div 3;
  159.         if Frac(Len / 3) > 0.0 then // always round up!
  160.           inc(Len1);
  161.         Len1 := Len1 * 4;
  162.         SetLength(Output, Len1 + 1);
  163.         LinePtr := PChar(Output);
  164.         OutChar1 := EncodeAByte(Len);
  165.         LinePtr^ := Chr(OutChar1);
  166.         inc(LinePtr);
  168.         while (index < TotalBytes) do
  169.         begin
  170.           if (index < TotalBytes) then
  171.           begin
  172.             if InputPtr >= BufferEnd then
  173.               if not MemStuff.NextMemoryBuffer(InputPtr, 0) then
  174.                 Break
  175.               else
  176.               begin
  177.                 InputPtr := MemStuff.BufPos;
  178.                 BufferEnd := MemStuff.BufEnd;
  179.               end;
  180.             Char1 := Byte(InputPtr^);
  181.             inc(InputPtr);
  182.           end
  183.           else
  184.           begin
  185.             Char1 := INVALID;
  186.           end;
  188.           inc(index);
  190.           if (index < TotalBytes) then
  191.           begin
  192.             if InputPtr >= BufferEnd then
  193.               if not MemStuff.NextMemoryBuffer(InputPtr, 0) then
  194.                 Break
  195.               else
  196.               begin
  197.                 InputPtr := MemStuff.BufPos;
  198.                 BufferEnd := MemStuff.BufEnd;
  199.               end;
  200.             Char2 := Byte(InputPtr^);
  201.             inc(InputPtr);
  202.           end
  203.           else
  204.           begin
  205.             Char2 := INVALID;
  206.           end;
  208.           inc(index);
  210.           if (index < TotalBytes) then
  211.           begin
  212.             if InputPtr >= BufferEnd then
  213.               if not MemStuff.NextMemoryBuffer(InputPtr, 0) then
  214.                 Break
  215.               else
  216.               begin
  217.                 InputPtr := MemStuff.BufPos;
  218.                 BufferEnd := MemStuff.BufEnd;
  219.               end;
  220.             Char3 := Byte(InputPtr^);
  221.             inc(InputPtr);
  222.           end
  223.           else
  224.           begin
  225.             Char3 := INVALID;
  226.           end;
  228.           inc(index);
  230.           OutChar1 := Char1 shr 2;
  231.           OutChar2 := (((Char1 shl 4) and $30) or ((Char2 shr 4) and $0F));
  232.           OutChar3 := (((Char2 shl 2) and $3C) or ((Char3 shr 6) and $03));
  233.           OutChar4 := Char3 and $3F;
  235.           OutChar1 := EncodeAByte(OutChar1);
  236.           OutChar2 := EncodeAByte(OutChar2);
  237.           OutChar3 := EncodeAByte(OutChar3);
  238.           OutChar4 := EncodeAByte(OutChar4);
  240.           LinePtr^ := Chr(OutChar1);
  241.           inc(LinePtr);
  242.           LinePtr^ := Chr(OutChar2);
  243.           inc(LinePtr);
  244.           LinePtr^ := Chr(OutChar3);
  245.           inc(LinePtr);
  246.           LinePtr^ := Chr(OutChar4);
  247.           inc(LinePtr);
  248.         end;
  249.         Process := False;
  250.       end;
  252.       LinePtr^ := #0;
  253.       destination.Write(PChar(Output)^, Length(Output));
  254.       destination.Write(CRLF, 2);
  255.     end;
  256.   finally
  257.     MemStuff.Free;
  258.   end;
  259.   Result := True; // no errors reported
  260. end;
  262. end.