Delphi 如何正确声明StreamLn

我正在尝试编译我的程序，但出现以下错误：

Undeclared indentifier 'StreamLn'

我甚至试着下载PSock.dcu并将其放入库中，但它无法编译，看起来它可以与delphi 5兼容

unit ResourceInfo;

interface

uses
  Classes, SysUtils, Windows;

type
  TResourceInfo = class;

  TDfmMode = ( dfmData, dfmResource, dfmASCII, dfmBinary);

  TDfm = class
  private
    FOwner: TResourceInfo;
    FName: string;
    FData: TStream;

    procedure SetName(const Value: string);
    procedure SetOwner(const Value: TResourceInfo);

  public
    constructor Create(AOwner: TResourceInfo);
    destructor Destroy; override;

    function SaveToFile(FileName: TFileName; Mode: TDfmMode): Boolean;

    property Data: TStream read FData;
    property Name: string read FName write SetName;
    property Owner: TResourceInfo read FOwner write FOwner;
  end; {TDfm}

  TResourceInfo = class(TComponent)
  private
    FActive: Boolean;
    FDfms: TList;
    FExeFileName: TFileName;
    FModule: THandle;
    FOnActivate: TNotifyEvent;
    FOnDeactivate: TNotifyEvent;

    procedure SetExeFileName(const Value: TFileName);
    procedure SetActive(const Value: Boolean);
    function  GetDfms(Index: Cardinal): TDfm;
    function  GetDfmCount: Cardinal;

  protected
    procedure Clear;

  public
    constructor Create(AOwner: TComponent); override;
    destructor  Destroy; override;

    function  AddDfm(const Name: string; AData: TMemoryStream): Integer;
    procedure DeleteDfm(const Name: string);
    property  DfmCount: Cardinal read GetDfmCount;
    property  Dfms[Index: Cardinal]: TDfm read GetDfms;
    procedure EnumDfmNames;
    property  Module: THandle read FModule;

  published
    property Active: Boolean read FActive write SetActive;
    property ExeFileName: TFileName read FExeFileName write SetExeFileName;

    property OnActivate: TNotifyEvent read FOnActivate write FOnActivate;
    property OnDeactivate: TNotifyEvent read FOnDeactivate write FOnDeactivate;
  end; {TResourceInfo}

procedure Register;

implementation

uses
 Winsock;

resourcestring
  rsErrorLoadingExeFile = 'An error ocurred loading file %s, it may not be an executable module';

procedure Register;
begin
  RegisterComponents('+HCU', [TResourceInfo]);
end; {Register}

{ TResourceInfo }

function TResourceInfo.AddDfm(const Name: string; AData: TMemoryStream): Integer;
var
  FDfm: TDfm;
begin
  FDfm := TDfm.Create(Self);
  FDfm.Name := Name;
  FDfm.Data.Size := AData.Size;
  FDfm.Data.Seek(0, 0);
  AData.Seek(0, 0);
  FDfm.Data.CopyFrom(AData, AData.Size);
  Result := FDfms.Add(FDfm);
end; {TResourceInfo.AddDfm}

constructor TResourceInfo.Create(AOwner: TComponent);
begin
  inherited;

  FActive := False;
  FDfms := TList.Create;
  FModule := 0;
end; {TResourceInfo.Create}

destructor TResourceInfo.Destroy;
begin
  Clear;
  FDfms.Free;

  inherited;
end; {TResourceInfo.Destroy}

function CB_EnumDfmNameProc(hModule: THandle; lpszType, lpszName: PChar; lParam: Integer): Boolean; stdcall;
var
  ms: TMemoryStream;
  rs: TResourceStream;
  Buffer: array of Byte;
begin
  with TResourceInfo(lParam) do
    begin
      rs := TResourceStream.Create(TResourceInfo(lParam).Module, lpszname, lpszType);
      try
        ms := TMemoryStream.Create;
        try
          try
            SetLength(Buffer, 4);
            rs.Read(Buffer[0], SizeOf(Buffer));
            if string(Buffer) = 'TPF0' then
              begin
                rs.Seek(0, 0);
                ObjectBinaryToText(rs, ms);
                ms.Seek(0, 0);
                AddDfm(StrPas(lpszName), ms);
              end;
          except
            raise;
          end;
        finally
          ms.Free;
        end;
      finally
        rs.free;
      end;
    end;

  Result := True;
end; {CB_EnumDfmNameProc}

procedure TResourceInfo.EnumDfmNames;
begin
  if FModule > 0 then
    EnumResourceNames(FModule, RT_RCDATA, @CB_EnumDfmNameProc, Integer(Self));
end; {TResourceInfo.EnumDfmNames}

procedure TResourceInfo.DeleteDfm(const Name: string);
var
  i: Cardinal;
begin
  if FDfms.Count > 0 then
    for i := Pred(FDfms.Count) downto 0 do
      if UpperCase(TDfm(FDfms[i]).Name) = UpperCase(Name) then
        begin
          FDfms.Delete(i);
          Break;
        end;
end; {TResourceInfo.DeleteDfm}

procedure TResourceInfo.SetActive(const Value: Boolean);
begin
  if FActive <> Value then
    begin
      if Value then
        begin
          if FModule > 0 then
            FreeLibrary(FModule);

            (* LOAD_LIBRARY_AS_DATAFILE
               If this value is given, the function does a simple mapping of the file into the
               address space. Nothing is done relative to executing or preparing to execute the
               code in the mapped file. The function loads the module as if it were a data file.
               You can use the module handle that the function returns in this case with the Win32
               functions that operate on resources. Use this flag when you want to load a DLL in
               order to extract messages or resources from it, and have no intention of executing
               its code.If this value is not given, the function maps the file into the address
               space in the manner that is normal for an executable module. The behavior of the
               function is then identical to that of LoadLibrary in this regard. *)

          FModule := LoadLibraryEx(PChar(FExeFileName), 0, LOAD_LIBRARY_AS_DATAFILE);
          if not (FModule >= 32) then
            raise Exception.CreateFmt(rsErrorLoadingExeFile, [FExeFileName]);
          if Assigned(FOnActivate) then
            FOnActivate(Self);
        end
      else
        begin
          Clear;
          if FModule > 0 then
            begin
              FreeLibrary(FModule);
              FModule := 0;
            end;
          if Assigned(FOnDeactivate) then
            FOnDeactivate(Self);
        end;
      FActive := Value;
    end;
end; {TResourceInfo.SetActive}

procedure TResourceInfo.SetExeFileName(const Value: TFileName);
begin
  if FExeFileName <> Value then
    FExeFileName := Value;
end; {TResourceInfo.SetExeFileName}

function TResourceInfo.GetDfms(Index: Cardinal): TDfm;
begin
  Result := TDfm(FDfms[Index]);
end; {TResourceInfo.GetDfms}

function TResourceInfo.GetDfmCount: Cardinal;
begin
  Result := FDfms.Count;
end; {TResourceInfo.GetDfmCount}

procedure TResourceInfo.Clear;
begin
  if FDfms.Count > 0 then
    while FDfms.Count > 0 do
      FDfms.Delete(0);
end; {TResourceInfo.Clear}

{ TDfm }

constructor TDfm.Create(AOwner: TResourceInfo);
begin
  inherited Create;

  FData := TMemoryStream.Create;
  FName := '';
  SetOwner(AOwner);
end; {TDfm.Create}

destructor TDfm.Destroy;
begin
  FData.Free;
  inherited;
end; {TDfm.Destroy}


function TDfm.SaveToFile(FileName: TFileName; Mode: TDfmMode): Boolean;

  function EndOfStream(Stream: TStream): Boolean;
  begin
    with Stream do
      Result := Position = Size;
  end; {EndOfStream}

var
  fs: TFileStream;
  ms: TMemoryStream;
  s: string;
  i, j: Byte;
begin
  fs := TFileStream.Create(FileName, fmCreate or fmShareExclusive);
  try
    FData.Seek(0, 0);

    case Mode of
      dfmASCII:
        begin
          ms := TMemoryStream.Create;
          try
            s := FName + ' RCDATA' + #13#10 + '{';
            StreamLN(fs, s);

            ObjectTextToBinary(FData, ms);
            ms.Seek(0, 0);

            while not EndOfStream(ms) do
              begin
                s := '''';

                for i := 0 to 15 do
                  begin
                    if ms.Read(j, SizeOf(j)) = 0 then
                      Break;
                    s := Concat(s, Format('%2.2x', [j]));
                    if (i = 15) or EndOfStream(ms) then
                      s := Concat(s, '''')
                    else
                      s := Concat(s, ' ');
                  end;

                if EndOfStream(ms) then
                  s := Concat(s, #13#10 + '}');
                StreamLN(fs, s);
              end;

          finally
            ms.Free;
          end;
        end;

      dfmBinary:
        ObjectTextToBinary(FData, fs);
    end;

  finally
    fs.Free;
  end;
end; {TDfm.SaveToFile}

procedure TDfm.SetName(const Value: string);
begin
  if FName <> Value then
    FName := Value;
end; {TDfm.SetName}

procedure TDfm.SetOwner(const Value: TResourceInfo);
begin
  FOwner := Value;
end; {TDfm.SetOwner}

end.

unitresourceinfo；
接口
使用
类、SysUtils、Windows；
类型
TResourceInfo=class；
TDfmMode=（dfmData、dfmResource、dfmASCII、DFMBINAL）；
TDfm=类
私有的
FOwner:TResourceInfo；
FName：字符串；
FData:TStream；
过程集合名（常量值：字符串）；
过程SetOwner（const值：TResourceInfo）；
公众的
构造函数创建（AOwner:TResourceInfo）；
毁灭者毁灭；推翻
函数SaveToFile（文件名：TFileName；模式：TDfmMode）：布尔；
属性数据：TStream读取FData；
属性名称：字符串读取FName写入SetName；
属性所有者：TResourceInfo读取FOwner写入FOwner；
结束；{TDfm}
TResourceInfo=class（TComponent）
私有的
事实：布尔；
FDfms:TList；
FExeFileName:TFileName；
模块：THandle；
激活：TNotifyEvent；
事件：TNotifyEvent；
过程SetExeFileName（常量值：TFileName）；
过程SetActive（常量值：布尔值）；
函数GetDfms（索引：基数）：TDfm；
函数GetDfmCount：基数；
受保护的
程序清晰；
公众的
构造函数创建（AOwner:TComponent）；推翻
毁灭者毁灭；推翻
函数AddDfm（const Name:string；AData:TMemoryStream）：整数；
过程DeleteDfm（const Name:string）；
属性DfmCount：基数读取GetDfmCount；
属性Dfms[索引：基数]：TDfm read GETDMS；
程序枚举名称；
属性模块：THandle read模块；
出版
属性活动：布尔读写设置活动；
属性ExeFileName:TFileName读取FExeFileName写入SetExeFileName；
activate属性：TNotifyEvent read FOnActivate write FOnActivate；
属性OnDeactivate:TNotifyEvent read FOnDeactivate write FOnDeactivate；
结束；{TResourceInfo}
程序登记册；
实施
使用
温索克；
资源字符串
rsErrorLoadingExeFile='加载文件%s时出错，它可能不是可执行模块'；
程序登记册；
开始
注册表组件（'+HCU'，[TResourceInfo]）；
结束；{寄存器}
{TResourceInfo}
函数TResourceInfo.AddDfm（const Name:string；AData:TMemoryStream）：整数；
变量
FDfm:TDfm；
开始
FDfm:=TDfm.Create（Self）；
FDfm.Name:=名称；
FDfm.Data.Size:=AData.Size；
FDfm.Data.Seek（0,0）；
AData.Seek（0,0）；
FDfm.Data.CopyFrom（AData，AData.Size）；
结果：=FDfms.Add（FDfm）；
结束；{TResourceInfo.AddDfm}
构造函数TResourceInfo.Create（AOwner:TComponent）；
开始
继承；
事实：=假；
FDfms:=TList.Create；
f模块：=0；
结束；{TResourceInfo.Create}
析构函数TResourceInfo.Destroy；
开始
清楚的
免费的；
继承；
结束；{TResourceInfo.Destroy}
函数CB_EnumDfmNameProc（hModule:THandle；lpszType，lpszName:PChar；lpram:Integer）：布尔；stdcall；
变量
ms:TMemoryStream；
rs:TResourceStream；
缓冲区：字节数组；
开始
使用TResourceInfo（LPRAM）执行以下操作
开始
rs:=TResourceStream.Create（TResourceInfo（lParam.Module，lpszname，lpszType）；
尝试
ms:=TMemoryStream.Create；
尝试
尝试
设置长度（缓冲区，4）；
rs.Read（缓冲区[0]，SizeOf（缓冲区））；
如果字符串（缓冲区）=“TPF0”，则
开始
rs.Seek（0,0）；
ObjectBinaryToText（rs，ms）；
Seek女士（0,0）；
AddDfm（StrPas（lpszName），ms）；
结束；
除了
提高；
结束；
最后
弗里女士；
结束；
最后
免费卢比；
结束；
结束；
结果：=真；
结束；{CB_EnumDfmNameProc}
过程TResourceInfo.EnumDfmNames；
开始
如果FModule>0，则
EnumResourceNames（FModule，RT_RCDATA，@CB_EnumDfmNameProc，Integer（Self））；
结束；{TResourceInfo.EnumDfmNames}
过程TResourceInfo.DeleteDfm（const Name:string）；
变量
i：红衣主教；
开始
如果FDfms.计数>0，则
对于i:=Pred（FDfms.Count）下降到0 do
如果大写（TDfm（FDfms[i]）.Name）=大写（Name），则
开始
删除（i）；
打破
结束；
结束；{TResourceInfo.DeleteDfm}
过程TResourceInfo.SetActive（常量值：布尔值）；
开始
如果是事实价值那么
开始
如果值那么
开始
如果FModule>0，则
免费图书馆（FModule）；
（*将库作为数据文件加载
如果给定此值，则函数将文件简单映射到
地址空间。执行或准备执行
映射文件中的代码。该函数加载模块时将其视为数据文件。
在本例中，您可以将函数返回的模块句柄用于Win32
在资源上操作的函数。如果要在中加载DLL，请使用此标志
从中提取消息或资源，并且无意执行
如果没有给出这个值，函数会将文件映射到地址
可执行模块的正常方式的空间
在这方面，函数与LoadLibrary的函数相同。*）
FModule:=LoadLibraryEx（PChar（FExeFileName），0，将库作为数据文件加载；
如果不是（FModule>=32），则
raiseexception.CreateFmt（rsErrorLoadingExeFile[FExeFileName]）；
如果已分配（激活），则
激活（自我）；
结束
其他的
开始
清楚的
如果FModule>0，则
开始
免费图书馆（FModule）；
f模块：=0；
结束；
如果分配（取消激活），则
（自我）；
结束；
事实：=价值；
结束；
结束；{TResourceInfo