* Split file according to Class; implemented dummys for all methods, so unit compiles.

fcl/inc/bits.inc

@@ -0,0 +1,137 @@
+{
+    $Id$
+    This file is part of the Free Component Library (FCL)
+    Copyright (c) 1998 by the Free Pascal development team
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+{****************************************************************************}
+{*                               TBits                                      *}
+{****************************************************************************}
+
+  procedure TBits.Error;
+
+    begin
+{$ifdef NoExceptions}
+         ;
+{$else}
+         Raise(EBitsError);
+{$endif}
+    end;
+
+  procedure TBits.SetSize(Value: Integer);
+
+    var
+       hp : pointer;
+       cvalue,csize : Integer;
+
+    begin
+       { ajust value to n*8 }
+       cvalue:=Value;
+       if cvalue mod 8<>0 then
+         cvalue:=cvalue+(8-(cvalue mod 8));
+
+       { store pointer to release it later }
+       hp:=FBits;
+
+       { ajust size to n*8 }
+       csize:=FSize;
+       if csize mod 8<>0 then
+         csize:=csize+(8-(csize mod 8));
+
+       if FSize>0 then
+         begin
+            { get new memory }
+            GetMem(FBits,cvalue div 8);
+            { clear the whole array }
+            FillChar(FBits^,cvalue div 8,0);
+            { copy old data }
+            Move(hp^,FBits^,csize div 8);
+         end
+       else
+         FBits:=nil;
+
+       if assigned(hp) then
+         FreeMem(hp,csize div 8);
+
+       FSize:=Value;
+    end;
+
+  procedure TBits.SetBit(Index: Integer; Value: Boolean);
+
+    type
+       pbyte = ^byte;
+
+    begin
+       if (Index>=FSize) or (Index<0)  then
+         Error
+       else
+         begin
+            if Value then
+              pbyte(FBits)[Index div 8]:=pbyte(FBits)[Index div 8] or
+                (1 shl (Index mod 8))
+            else
+              pbyte(FBits)[Index div 8]:=pbyte(FBits)[Index div 8] and
+                not(1 shl (Index mod 8));
+         end;
+    end;
+
+  function TBits.GetBit(Index: Integer): Boolean;
+
+    type
+       pbyte = ^byte;
+
+    begin
+       if (Index>=FSize) or (Index<0) then
+         Error
+       else
+         GetBit:=(pbyte(FBits)[Index div 8] and (1 shl (Index mod 8)))<>0;
+    end;
+
+  destructor TBits.Destroy;
+
+    var
+       csize : Integer;
+
+    begin
+       { ajust size to n*8 }
+       csize:=FSize;
+       if csize mod 8<>0 then
+         csize:=csize+(8-(csize mod 8));
+       if assigned(FBits) then
+         FreeMem(FBits,csize);
+       inherited Destroy;
+    end;
+
+  function TBits.OpenBit: Integer;
+
+    type
+       pbyte = ^byte;
+
+    var
+       i : Integer;
+
+    begin
+       for i:=0 to FSize-1 do
+         if (pbyte(FBits)[i div 8] and (1 shl (i mod 8)))=0 then
+           begin
+              OpenBit:=i;
+              exit;
+           end;
+       SetSize(FSize+1);
+       OpenBit:=FSize-1;
+    end;
+
+
+{
+  $Log$
+  Revision 1.1  1998-05-04 14:30:11  michael
+  * Split file according to Class; implemented dummys for all methods, so unit compiles.
+
+}

fcl/inc/classes.inc

@@ -12,504 +12,353 @@
 
  **********************************************************************}
 
-{****************************************************************************}
-{*                               TBits                                      *}
-{****************************************************************************}
-
-  procedure TBits.Error;
-
-    begin
-{$ifdef NoExceptions}
-         ;
-{$else}
-         Raise(EBitsError);
-{$endif}
-    end;
-
-  procedure TBits.SetSize(Value: Integer);
-
-    var
-       hp : pointer;
-       cvalue,csize : Integer;
-
-    begin
-       { ajust value to n*8 }
-       cvalue:=Value;
-       if cvalue mod 8<>0 then
-         cvalue:=cvalue+(8-(cvalue mod 8));
-
-       { store pointer to release it later }
-       hp:=FBits;
-
-       { ajust size to n*8 }
-       csize:=FSize;
-       if csize mod 8<>0 then
-         csize:=csize+(8-(csize mod 8));
-
-       if FSize>0 then
-         begin
-            { get new memory }
-            GetMem(FBits,cvalue div 8);
-            { clear the whole array }
-            FillChar(FBits^,cvalue div 8,0);
-            { copy old data }
-            Move(hp^,FBits^,csize div 8);
-         end
-       else
-         FBits:=nil;
-
-       if assigned(hp) then
-         FreeMem(hp,csize div 8);
-
-       FSize:=Value;
-    end;
-
-  procedure TBits.SetBit(Index: Integer; Value: Boolean);
-
-    type
-       pbyte = ^byte;
-
-    begin
-       if (Index>=FSize) or (Index<0)  then
-         Error
-       else
-         begin
-            if Value then
-              pbyte(FBits)[Index div 8]:=pbyte(FBits)[Index div 8] or
-                (1 shl (Index mod 8))
-            else
-              pbyte(FBits)[Index div 8]:=pbyte(FBits)[Index div 8] and
-                not(1 shl (Index mod 8));
-         end;
-    end;
-
-  function TBits.GetBit(Index: Integer): Boolean;
-
-    type
-       pbyte = ^byte;
-
-    begin
-       if (Index>=FSize) or (Index<0) then
-         Error
-       else
-         GetBit:=(pbyte(FBits)[Index div 8] and (1 shl (Index mod 8)))<>0;
-    end;
-
-  destructor TBits.Destroy;
-
-    var
-       csize : Integer;
-
-    begin
-       { ajust size to n*8 }
-       csize:=FSize;
-       if csize mod 8<>0 then
-         csize:=csize+(8-(csize mod 8));
-       if assigned(FBits) then
-         FreeMem(FBits,csize);
-       inherited Destroy;
-    end;
-
-  function TBits.OpenBit: Integer;
-
-    type
-       pbyte = ^byte;
-
-    var
-       i : Integer;
-
-    begin
-       for i:=0 to FSize-1 do
-         if (pbyte(FBits)[i div 8] and (1 shl (i mod 8)))=0 then
-           begin
-              OpenBit:=i;
-              exit;
-           end;
-       SetSize(FSize+1);
-       OpenBit:=FSize-1;
-    end;
-
-{****************************************************************************}
-{*                             TStream                                      *}
-{****************************************************************************}
-
-  function TStream.GetPosition: Longint;
-
-    begin
-       GetPosition:=Seek(0,soFromCurrent);
-    end;
-
-  procedure TStream.SetPosition(Pos: Longint);
-
-    begin
-       Seek(soFromBeginning,Pos);
-    end;
-
-  function TStream.GetSize: Longint;
-
-    var
-       p : longint;
-
-    begin
-       p:=GetPosition;
-       GetSize:=Seek(soFromEnd,0);
-       Seek(soFromBeginning,p);
-    end;
-
-  procedure TStream.SetSize(NewSize: Longint);
-
-    begin
-       SetPosition(NewSize);
-    end;
-
-  procedure TStream.ReadBuffer(var Buffer; Count: Longint);
-
-    begin
-       if Read(Buffer,Count)<Count then
-{$ifdef NoExceptions}
-         ;
-{$else}
-         Raise(EReadError);
-{$endif}
-    end;
-
-  procedure TStream.WriteBuffer(const Buffer; Count: Longint);
-
-    begin
-       if Write(Buffer,Count)<Count then
-{$ifdef NoExceptions}
-         ;
-{$else}
-         Raise(EWriteError);
-{$endif}
-    end;
-
-  function TStream.CopyFrom(Source: TStream; Count: Longint): Longint;
-
-    var
-       i : longint;
-       buffer : array[0..1023] of byte;
-
-    begin
-       CopyFrom:=0;
-       while Count>0 do
-         begin
-            if (Count>sizeof(buffer)) then
-              i:=sizeof(Buffer)
-            else
-              i:=Count;
-            i:=Source.Read(buffer,i);
-            i:=Write(buffer,i);
-            dec(count,i);
-            CopyFrom:=CopyFrom+i;
-            if i=0 then
-              exit;
-         end;
-    end;
-
-  function TStream.ReadComponent(Instance: TComponent): TComponent;
-
-    var
-       Reader : TReader;
-
-    begin
-       Reader.Create(Self,1024);
-       if assigned(Instance) then
-         ReadComponent:=Reader.ReadRootComponent(Instance)
-       else
-         begin
-            {!!!!!}
-         end;
-       Reader.Destroy;
-    end;
-
-  function TStream.ReadComponentRes(Instance: TComponent): TComponent;
-
-    begin
-       {!!!!!}
-    end;
-
-  procedure TStream.WriteComponent(Instance: TComponent);
-
-    var
-       Writer : TWriter;
-
-    begin
-       Writer.Create(Self,1024);
-       Writer.WriteRootComponent(Instance);
-       Writer.Destroy;
-    end;
-
-  procedure TStream.WriteComponentRes(const ResName: string; Instance: TComponent);
-
-    var
-       startpos,s : longint;
-
-    begin
-(* 
-{$ifdef Win16Res}
-       { Numeric resource type }
-       WriteByte($ff);
-       { Application defined data }
-       WriteWord($0a);
-       { write the name as asciiz }
-       WriteData(ResName[1],length(ResName));
-       WriteByte(0);
-       { Movable, Pure and Discardable }
-       WriteWord($1030);
-       { size isn't known yet }
-       WriteDWord(0);
-       startpos:=GetPosition;
-       WriteComponent(Instance);
-       { calculate size }
-       s:=GetPosition-startpos;
-       { back patch size }
-       SetPosition(startpos-4);
-       WriteDWord(s);
-{$endif Win16Res}
-*)
-    end;
-
-  procedure TStream.WriteDescendent(Instance, Ancestor: TComponent);
-
-    begin
-       {!!!!!}
-    end;
-
-  procedure TStream.WriteDescendentRes(const ResName: string; Instance, Ancestor: TComponent);
-
-    begin
-       {!!!!!}
-    end;
-
-  procedure TStream.ReadResHeader;
-
-    begin
-{$ifdef Win16Res}
-       try
-         { application specific resource ? }
-         if ReadByte<>$ff then
-           raise EInvalidImage;
-         if ReadWord<>$000a then
-           raise EInvalidImage;
-         { read name }
-         while ReadByte<>0 do
-           ;
-         { check the access specifier }
-         if ReadWord<>$1030 then
-           raise EInvalidImage;
-         { ignore the size }
-         ReadDWord;
-       except
-{/////
-         on EInvalidImage do
-           raise;
-         else
-           raise(EInvalidImage);
-}
-       end;
-{$endif Win16Res}
-    end;
+{**********************************************************************
+ *       Class implementations are in separate files.                 *
+ **********************************************************************}
 
-  function TStream.ReadByte : Byte;
+{ TBits implementation }
+{$i bits.inc}
 
-    var
-       b : Byte;
+{ TReader implementation }
+{$i reader.inc}
 
-    begin
-       ReadBuffer(b,1);
-       ReadByte:=b;
-    end;
+{ TWriter implementation }
+{$i writer.inc}
 
-  function TStream.ReadWord : Word;
+{ TFiler implementation }
+{$i filer.inc}
 
-    var
-       w : Word;
+{ All streams implementations: }
+{ Tstreams THandleStream TFileStream TResourcseStreams TStringStream }
+{ TCustomMemoryStream TMemoryStream }
+{$i streams.inc}
 
-    begin
-       ReadBuffer(w,2);
-       ReadWord:=w;
-    end;
+{ TParser implementation}
+{$i parser.inc}
 
-  function TStream.ReadDWord : Cardinal;
+{ TCollection and TCollectionItem implementations }
+{$i collect.inc}
 
-    var
-       d : Cardinal;
+{ TList and TThreadList implementations }
+{$i lists.inc}
 
-    begin
-       ReadBuffer(d,4);
-       ReadDWord:=d;
-    end;
+{ TStrings and TStringList implementations }
+{$i strings.inc}
 
-  procedure TStream.WriteByte(b : Byte);
+{ TThread implementation }
+{$i thread.inc}
 
-    begin
-       WriteBuffer(b,1);
-    end;
+{ TPersistent implementation }
+{$i persist.inc }
 
-  procedure TStream.WriteWord(w : Word);
+{ TComponent implementation }
+{$i compon.inc}
 
-    begin
-       WriteBuffer(w,2);
-    end;
+{**********************************************************************
+ *       Miscellaneous procedures and functions                       *
+ **********************************************************************}
 
-  procedure TStream.WriteDWord(d : Cardinal);
+{ Point and rectangle constructors }
 
-    begin
-       WriteBuffer(d,4);
-    end;
+function Point(AX, AY: Integer): TPoint;
 
-{****************************************************************************}
-{*                             TList                                        *}
-{****************************************************************************}
+begin
+end;
 
-{  TList = class(TObject)
-  private
-    FList: PPointerList;
-    FCount: Integer;
-    FCapacity: Integer;
-}
 
-function TList.Get(Index: Integer): Pointer;
+function SmallPoint(AX, AY: SmallInt): TSmallPoint;
 
 begin
 end;
 
 
+function Rect(ALeft, ATop, ARight, ABottom: Integer): TRect;
 
-procedure TList.Grow;
+begin
+end;
+
+
+function Bounds(ALeft, ATop, AWidth, AHeight: Integer): TRect;
 
 begin
 end;
 
 
 
-procedure TList.Put(Index: Integer; Item: Pointer);
+{ Class registration routines }
+
+procedure RegisterClass(AClass: TPersistentClass);
 
 begin
 end;
 
 
+procedure RegisterClasses(AClasses: array of TPersistentClass);
+
+begin
+end;
+
 
-procedure TList.SetCapacity(NewCapacity: Integer);
+procedure RegisterClassAlias(AClass: TPersistentClass; const Alias: string);
 
 begin
 end;
 
 
+procedure UnRegisterClass(AClass: TPersistentClass);
 
-procedure TList.SetCount(NewCount: Integer);
+begin
+end;
+
+
+procedure UnRegisterClasses(AClasses: array of TPersistentClass);
 
 begin
 end;
 
 
+procedure UnRegisterModuleClasses(Module: HMODULE);
+
+begin
+end;
+
 
-destructor TList.Destroy;
+function FindClass(const ClassName: string): TPersistentClass;
 
 begin
-  Clear;
-  inherited Destroy;
 end;
 
 
-Function TList.Add(Item: Pointer): Integer;
+function GetClass(const ClassName: string): TPersistentClass;
 
 begin
-  Self.Insert (Count,Item);
 end;
 
 
 
-Procedure TList.Clear;
+{ Component registration routines }
+
+procedure RegisterComponents(const Page: string;
+  ComponentClasses: array of TComponentClass);
 
 begin
 end;
 
 
+procedure RegisterNoIcon(ComponentClasses: array of TComponentClass);
 
-Procedure TList.Delete(Index: Integer);
+begin
+end;
 
 
+procedure RegisterNonActiveX(ComponentClasses: array of TComponentClass;
+  AxRegType: TActiveXRegType);
 
 begin
 end;
 
 
-class procedure Error(const Msg: string; Data: Integer);
+
+
+{ Object filing routines }
+
+procedure RegisterIntegerConsts(IntegerType: Pointer; IdentToInt: TIdentToInt;
+  IntToIdent: TIntToIdent);
 
 begin
 end;
 
-procedure TList.Exchange(Index1, Index2: Integer);
 
+function IdentToInt(const Ident: string; var Int: Longint; const Map: array of TIdentMapEntry): Boolean;
 
 begin
 end;
 
 
+function IntToIdent(Int: Longint; var Ident: string; const Map: array of TIdentMapEntry): Boolean;
 
-function TList.Expand: TList;
+begin
+end;
+
+
+function InitInheritedComponent(Instance: TComponent; RootAncestor: TClass): Boolean;
+
+begin
+end;
 
 
+function InitComponentRes(const ResName: string; Instance: TComponent): Boolean;
+
 begin
 end;
 
 
-function TList.First: Pointer;
+function ReadComponentRes(const ResName: string; Instance: TComponent): TComponent;
 
 begin
 end;
 
 
+function ReadComponentResEx(HInstance: THandle; const ResName: string): TComponent;
+
+begin
+end;
+
+
+function ReadComponentResFile(const FileName: string; Instance: TComponent): TComponent;
+
+begin
+end;
 
-function TList.IndexOf(Item: Pointer): Integer;
+
+procedure WriteComponentResFile(const FileName: string; Instance: TComponent);
 
 begin
 end;
 
 
 
-procedure TList.Insert(Index: Integer; Item: Pointer);
+procedure GlobalFixupReferences;
 
 begin
 end;
 
 
+procedure GetFixupReferenceNames(Root: TComponent; Names: TStrings);
+
+begin
+end;
+
 
-function TList.Last: Pointer;
+procedure GetFixupInstanceNames(Root: TComponent;
+  const ReferenceRootName: string; Names: TStrings);
 
 begin
 end;
 
 
-procedure TList.Move(CurIndex, NewIndex: Integer);
+procedure RedirectFixupReferences(Root: TComponent; const OldRootName,
+  NewRootName: string);
 
 begin
 end;
 
 
-function TList.Remove(Item: Pointer): Integer;
+procedure RemoveFixupReferences(Root: TComponent; const RootName: string);
 
 begin
 end;
 
 
+procedure RemoveFixups(Instance: TPersistent);
 
-procedure TList.Pack;
 begin
 end;
 
 
 
-procedure TList.Sort(Compare: TListSortCompare);
+procedure BeginGlobalLoading;
 
 begin
 end;
 
+
+procedure NotifyGlobalLoading;
+
+begin
+end;
+
+
+procedure EndGlobalLoading;
+
+begin
+end;
+
+
+
+function CollectionsEqual(C1, C2: TCollection): Boolean;
+
+begin
+end;
+
+
+
+{ Object conversion routines }
+
+procedure ObjectBinaryToText(Input, Output: TStream);
+
+begin
+end;
+
+
+procedure ObjectTextToBinary(Input, Output: TStream);
+
+begin
+end;
+
+
+procedure ObjectResourceToText(Input, Output: TStream);
+
+begin
+end;
+
+
+procedure ObjectTextToResource(Input, Output: TStream);
+
+begin
+end;
+
+
+
+{ Utility routines }
+
+function LineStart(Buffer, BufPos: PChar): PChar;
+
+begin
+end;
+
+
+
+
+{
+  $Log$
+  Revision 1.2  1998-05-04 14:30:11  michael
+  * Split file according to Class; implemented dummys for all methods, so unit compiles.
+
+  Revision 1.9  1998/05/04 12:16:01  florian
+    + Initial revisions after making a new directory structure
+
+  Revision 1.8  1998/05/04 11:20:13  florian
+    + Write* and Read* methods to TStream added
+    * small problems solved
+
+  Revision 1.7  1998/05/04 09:39:51  michael
+  + Started implementation of TList
+
+  Revision 1.6  1998/05/01 22:17:19  florian
+    + TBits implemented
+    + TStream partial implemented
+
+  Revision 1.5  1998/05/01 17:53:12  florian
+    * now it compiles with FPC
+
+  Revision 1.4  1998/04/28 11:47:00  florian
+    * more adaptions to FPC
+
+  Revision 1.3  1998/04/27 12:55:57  florian
+    + uses objpas added
+
+  Revision 1.2  1998/04/27 09:09:49  michael
+  + Added log at the end
+
+}
+
 {
   $Log$
-  Revision 1.1  1998-05-04 12:16:01  florian
+  Revision 1.2  1998-05-04 14:30:11  michael
+  * Split file according to Class; implemented dummys for all methods, so unit compiles.
+
+  Revision 1.1  1998/05/04 12:16:01  florian
     + Initial revisions after making a new directory structure
 
 }

fcl/inc/classesh.inc

@@ -237,7 +237,7 @@ type
     procedure SetIndex(Value: Integer); virtual;
     procedure SetDisplayName(const Value: string); virtual;
   public
-    constructor Create(Collection: TCollection); virtual;
+    constructor Create(ACollection: TCollection); virtual;
     destructor Destroy; override;
     property Collection: TCollection read FCollection write SetCollection;
     property ID: Integer read FID;
@@ -271,7 +271,7 @@ type
     procedure Update(Item: TCollectionItem); virtual;
     property PropName: string read GetPropName write FPropName;
   public
-    constructor Create(ItemClass: TCollectionItemClass);
+    constructor Create(AItemClass: TCollectionItemClass);
     destructor Destroy; override;
     function Add: TCollectionItem;
     procedure Assign(Source: TPersistent); override;
@@ -330,13 +330,13 @@ type
     function Add(const S: string): Integer; virtual;
     function AddObject(const S: string; AObject: TObject): Integer; virtual;
     procedure Append(const S: string);
-    procedure AddStrings(Strings: TStrings); virtual;
+    procedure AddStrings(TheStrings: TStrings); virtual;
     procedure Assign(Source: TPersistent); override;
     procedure BeginUpdate;
     procedure Clear; virtual; abstract;
     procedure Delete(Index: Integer); virtual; abstract;
     procedure EndUpdate;
-    function Equals(Strings: TStrings): Boolean;
+    function Equals(TheStrings: TStrings): Boolean;
     procedure Exchange(Index1, Index2: Integer); virtual;
     function GetText: PChar; virtual;
     function IndexOf(const S: string): Integer; virtual;
@@ -350,7 +350,7 @@ type
     procedure Move(CurIndex, NewIndex: Integer); virtual;
     procedure SaveToFile(const FileName: string); virtual;
     procedure SaveToStream(Stream: TStream); virtual;
-    procedure SetText(Text: PChar); virtual;
+    procedure SetText(TheText: PChar); virtual;
     property Capacity: Integer read GetCapacity write SetCapacity;
     property CommaText: string read GetCommaText write SetCommaText;
     property Count: Integer read GetCount;
@@ -864,7 +864,7 @@ type
     FDesignInfo: Longint;
     FVCLComObject: Pointer;
     FComponentState: TComponentState;
-    function GetComObject: IUnknown;
+    // function GetComObject: IUnknown;
     function GetComponent(AIndex: Integer): TComponent;
     function GetComponentCount: Integer;
     function GetComponentIndex: Integer;
@@ -927,7 +927,7 @@ type
     procedure RemoveComponent(AComponent: TComponent);
     function SafeCallException(ExceptObject: TObject;
       ExceptAddr: Pointer): Integer; override;
-    property ComObject: IUnknown read GetComObject;
+    // property ComObject: IUnknown read GetComObject;
     property Components[Index: Integer]: TComponent read GetComponent;
     property ComponentCount: Integer read GetComponentCount;
     property ComponentIndex: Integer read GetComponentIndex write SetComponentIndex;
@@ -1043,7 +1043,10 @@ function LineStart(Buffer, BufPos: PChar): PChar;
 
 {
   $Log$
-  Revision 1.1  1998-05-04 12:16:01  florian
+  Revision 1.2  1998-05-04 14:30:11  michael
+  * Split file according to Class; implemented dummys for all methods, so unit compiles.
+
+  Revision 1.1  1998/05/04 12:16:01  florian
     + Initial revisions after making a new directory structure
 
 }

fcl/inc/collect.inc

@@ -0,0 +1,238 @@
+{
+    $Id$
+    This file is part of the Free Component Library (FCL)
+    Copyright (c) 1998 by the Free Pascal development team
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+{****************************************************************************}
+{*                             TCollectionItem                              *}
+{****************************************************************************}
+
+
+function TCollectionItem.GetIndex: Integer;
+
+begin
+end;
+
+
+
+procedure TCollectionItem.SetCollection(Value: TCollection);
+
+begin
+end;
+
+
+
+procedure TCollectionItem.Changed(AllItems: Boolean);
+
+begin
+end;
+
+
+
+function TCollectionItem.GetNamePath: string;
+
+begin
+end;
+
+
+function TCollectionItem.GetOwner: TPersistent;
+
+begin
+end;
+
+
+
+function TCollectionItem.GetDisplayName: string; 
+
+begin
+end;
+
+
+
+procedure TCollectionItem.SetIndex(Value: Integer);
+
+begin
+end;
+
+
+procedure TCollectionItem.SetDisplayName(const Value: string);
+
+begin
+end;
+
+
+
+constructor TCollectionItem.Create(ACollection: TCollection); 
+
+begin
+end;
+
+
+
+destructor TCollectionItem.Destroy; 
+
+begin
+end;
+
+{****************************************************************************}
+{*                             TCollection                                  *}
+{****************************************************************************}
+
+
+
+function TCollection.GetCount: Integer;
+
+begin
+end;
+
+
+
+function TCollection.GetPropName: string;
+
+begin
+end;
+
+
+
+procedure TCollection.InsertItem(Item: TCollectionItem);
+
+begin
+end;
+
+
+
+procedure TCollection.RemoveItem(Item: TCollectionItem);
+
+begin
+end;
+
+
+function TCollection.GetAttrCount: Integer; 
+
+begin
+end;
+
+
+function TCollection.GetAttr(Index: Integer): string; 
+
+begin
+end;
+
+
+
+function TCollection.GetItemAttr(Index, ItemIndex: Integer): string; 
+
+begin
+end;
+
+
+
+function TCollection.GetNamePath: string; 
+
+begin
+end;
+
+
+
+procedure TCollection.Changed;
+
+begin
+end;
+
+
+
+function TCollection.GetItem(Index: Integer): TCollectionItem;
+
+begin
+end;
+
+
+
+procedure TCollection.SetItem(Index: Integer; Value: TCollectionItem);
+
+begin
+end;
+
+
+
+procedure TCollection.SetItemName(Item: TCollectionItem); 
+
+begin
+end;
+
+
+
+procedure TCollection.Update(Item: TCollectionItem);
+
+begin
+end;
+
+
+
+constructor TCollection.Create(AItemClass: TCollectionItemClass);
+
+begin
+end;
+
+
+
+destructor TCollection.Destroy; 
+
+begin
+end;
+
+
+
+function TCollection.Add: TCollectionItem;
+
+begin
+end;
+
+
+
+procedure TCollection.Assign(Source: TPersistent);
+
+begin
+end;
+
+
+
+procedure TCollection.BeginUpdate;
+
+begin
+end;
+
+
+
+procedure TCollection.Clear;
+
+begin
+end;
+
+
+
+procedure TCollection.EndUpdate;
+
+begin
+end;
+
+
+
+function TCollection.FindItemID(ID: Integer): TCollectionItem;
+
+begin
+end;
+{
+  $Log$
+  Revision 1.1  1998-05-04 14:30:11  michael
+  * Split file according to Class; implemented dummys for all methods, so unit compiles.
+
+}

fcl/inc/compon.inc

@@ -0,0 +1,297 @@
+{
+    $Id$
+    This file is part of the Free Component Library (FCL)
+    Copyright (c) 1998 by the Free Pascal development team
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+
+{****************************************************************************}
+{*                             TComponent                                   *}
+{****************************************************************************}
+
+
+Function  TComponent.GetComponent(AIndex: Integer): TComponent;
+
+begin
+end;
+
+
+Function  TComponent.GetComponentCount: Integer;
+
+begin
+end;
+
+
+Function  TComponent.GetComponentIndex: Integer;
+
+begin
+end;
+
+
+Procedure TComponent.Insert(AComponent: TComponent);
+
+begin
+end;
+
+
+Procedure TComponent.ReadLeft(Reader: TReader);
+
+begin
+end;
+
+
+Procedure TComponent.ReadTop(Reader: TReader);
+
+begin
+end;
+
+
+Procedure TComponent.Remove(AComponent: TComponent);
+
+begin
+end;
+
+
+Procedure TComponent.SetComponentIndex(Value: Integer);
+
+begin
+end;
+
+
+Procedure TComponent.SetReference(Enable: Boolean);
+
+begin
+end;
+
+
+Procedure TComponent.WriteLeft(Writer: TWriter);
+
+begin
+end;
+
+
+Procedure TComponent.WriteTop(Writer: TWriter);
+
+begin
+end;
+
+
+Procedure TComponent.ChangeName(const NewName: TComponentName);
+
+begin
+end;
+
+
+Procedure TComponent.DefineProperties(Filer: TFiler); 
+
+begin
+end;
+
+
+Procedure TComponent.GetChildren(Proc: TGetChildProc; Root: TComponent);
+
+begin
+end;
+
+
+Function  TComponent.GetChildOwner: TComponent;
+
+begin
+end;
+
+
+Function  TComponent.GetChildParent: TComponent; 
+
+begin
+end;
+
+
+Function  TComponent.GetNamePath: string; 
+
+begin
+end;
+
+
+Function  TComponent.GetOwner: TPersistent; 
+
+begin
+end;
+
+
+Procedure TComponent.Loaded; 
+
+begin
+end;
+
+
+Procedure TComponent.Notification(AComponent: TComponent;
+  Operation: TOperation);
+
+begin
+end;
+
+
+Procedure TComponent.ReadState(Reader: TReader); 
+
+begin
+end;
+
+
+Procedure TComponent.SetAncestor(Value: Boolean);
+
+begin
+end;
+
+
+Procedure TComponent.SetDesigning(Value: Boolean);
+
+begin
+end;
+
+
+Procedure TComponent.SetName(const NewName: TComponentName); 
+
+begin
+end;
+
+
+Procedure TComponent.SetChildOrder(Child: TComponent; Order: Integer);
+
+begin
+end;
+
+
+Procedure TComponent.SetParentComponent(Value: TComponent);
+
+begin
+end;
+
+
+Procedure TComponent.Updating; 
+
+begin
+end;
+
+
+Procedure TComponent.Updated; 
+
+begin
+end;
+
+
+class Procedure TComponent.UpdateRegistry(Register: Boolean; const ClassID, ProgID: string); 
+
+begin
+end;
+
+
+Procedure TComponent.ValidateRename(AComponent: TComponent;
+  const CurName, NewName: string); 
+
+begin
+end;
+
+
+Procedure TComponent.ValidateContainer(AComponent: TComponent); 
+
+begin
+end;
+
+
+Procedure TComponent.ValidateInsert(AComponent: TComponent); 
+
+begin
+end;
+
+
+Procedure TComponent.WriteState(Writer: TWriter); 
+
+begin
+end;
+
+
+Constructor TComponent.Create(AOwner: TComponent); 
+
+begin
+end;
+
+
+Destructor TComponent.Destroy; 
+
+begin
+end;
+
+
+Procedure TComponent.DestroyComponents;
+
+begin
+end;
+
+
+Procedure TComponent.Destroying;
+
+begin
+end;
+
+
+Function  TComponent.FindComponent(const AName: string): TComponent;
+
+begin
+end;
+
+
+Procedure TComponent.FreeNotification(AComponent: TComponent);
+
+begin
+end;
+
+
+Procedure TComponent.FreeOnRelease;
+
+begin
+end;
+
+
+Function  TComponent.GetParentComponent: TComponent; 
+
+begin
+end;
+
+
+Function  TComponent.HasParent: Boolean; 
+
+begin
+end;
+
+
+Procedure TComponent.InsertComponent(AComponent: TComponent);
+
+begin
+end;
+
+
+Procedure TComponent.RemoveComponent(AComponent: TComponent);
+
+begin
+end;
+
+
+Function  TComponent.SafeCallException(ExceptObject: TObject;
+  ExceptAddr: Pointer): Integer; 
+
+begin
+end;
+
+{
+  $Log$
+  Revision 1.1  1998-05-04 14:30:11  michael
+  * Split file according to Class; implemented dummys for all methods, so unit compiles.
+
+}

fcl/inc/filer.inc

@@ -0,0 +1,32 @@
+{
+    $Id$
+    This file is part of the Free Component Library (FCL)
+    Copyright (c) 1998 by the Free Pascal development team
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+{ *********************************************************************
+  *                         TFiler                                    *
+  *********************************************************************}
+
+Constructor TFiler.Create(Stream: TStream; BufSize: Integer);
+
+begin
+end;
+
+
+Destructor TFiler.Destroy;
+
+begin
+end;{
+  $Log$
+  Revision 1.1  1998-05-04 14:30:11  michael
+  * Split file according to Class; implemented dummys for all methods, so unit compiles.
+
+}

fcl/inc/lists.inc

@@ -0,0 +1,217 @@
+{
+    $Id$
+    This file is part of the Free Component Library (FCL)
+    Copyright (c) 1998 by the Free Pascal development team
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+{****************************************************************************}
+{*                             TList                                        *}
+{****************************************************************************}
+
+{  TList = class(TObject)
+  private
+    FList: PPointerList;
+    FCount: Integer;
+    FCapacity: Integer;
+}
+
+function TList.Get(Index: Integer): Pointer;
+
+begin
+end;
+
+
+
+procedure TList.Grow;
+
+begin
+end;
+
+
+
+procedure TList.Put(Index: Integer; Item: Pointer);
+
+begin
+end;
+
+
+
+procedure TList.SetCapacity(NewCapacity: Integer);
+
+begin
+end;
+
+
+
+procedure TList.SetCount(NewCount: Integer);
+
+begin
+end;
+
+
+
+destructor TList.Destroy;
+
+begin
+  Clear;
+  inherited Destroy;
+end;
+
+
+Function TList.Add(Item: Pointer): Integer;
+
+begin
+//  Self.Insert (Count,Item);
+end;
+
+
+
+Procedure TList.Clear;
+
+begin
+end;
+
+
+
+Procedure TList.Delete(Index: Integer);
+
+begin
+end;
+
+
+class procedure TList.Error(const Msg: string; Data: Integer);
+
+begin
+end;
+
+procedure TList.Exchange(Index1, Index2: Integer);
+
+
+begin
+end;
+
+
+
+function TList.Expand: TList;
+
+
+begin
+end;
+
+
+function TList.First: Pointer;
+
+begin
+end;
+
+
+
+function TList.IndexOf(Item: Pointer): Integer;
+
+begin
+end;
+
+
+
+procedure TList.Insert(Index: Integer; Item: Pointer);
+
+begin
+end;
+
+
+
+function TList.Last: Pointer;
+
+begin
+end;
+
+
+procedure TList.Move(CurIndex, NewIndex: Integer);
+
+begin
+end;
+
+
+function TList.Remove(Item: Pointer): Integer;
+
+begin
+end;
+
+
+
+procedure TList.Pack;
+begin
+end;
+
+
+
+procedure TList.Sort(Compare: TListSortCompare);
+
+begin
+end;
+
+
+{****************************************************************************}
+{*                             TThreadList                                  *}
+{****************************************************************************}
+
+
+constructor TThreadList.Create;
+
+begin
+end;
+
+
+    
+destructor TThreadList.Destroy; 
+
+begin
+end;
+
+
+
+procedure TThreadList.Add(Item: Pointer);
+
+begin
+end;
+
+
+procedure TThreadList.Clear;
+
+begin
+end;
+
+
+
+function TThreadList.LockList: TList;
+
+begin
+end;
+
+
+
+procedure TThreadList.Remove(Item: Pointer);
+
+
+begin
+end;
+
+
+
+procedure TThreadList.UnlockList;
+
+begin
+end;
+{
+  $Log$
+  Revision 1.1  1998-05-04 14:30:12  michael
+  * Split file according to Class; implemented dummys for all methods, so unit compiles.
+
+}

fcl/inc/parser.inc

@@ -0,0 +1,124 @@
+{
+    $Id$
+    This file is part of the Free Component Library (FCL)
+    Copyright (c) 1998 by the Free Pascal development team
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+{****************************************************************************}
+{*                             TParser                                      *}
+{****************************************************************************}
+
+Procedure TParser.ReadBuffer;
+
+begin
+end;
+
+
+Procedure TParser.SkipBlanks;
+
+begin
+end;
+
+
+constructor TParser.Create(Stream: TStream);
+
+begin
+end;
+
+
+destructor TParser.Destroy;
+
+begin
+end;
+
+
+Procedure TParser.CheckToken(T: Char);
+
+begin
+end;
+
+
+Procedure TParser.CheckTokenSymbol(const S: string);
+
+begin
+end;
+
+
+Procedure TParser.Error(const Ident: string);
+
+begin
+end;
+
+
+{!!!!!!
+Procedure TParser.ErrorFmt(const Ident: string; const Args: array of const);
+
+begin
+end;
+!!!!!!}
+
+Procedure TParser.ErrorStr(const Message: string);
+
+begin
+end;
+
+
+Procedure TParser.HexToBinary(Stream: TStream);
+
+begin
+end;
+
+
+Function TParser.NextToken: Char;
+
+begin
+end;
+
+
+Function TParser.SourcePos: Longint;
+
+begin
+end;
+
+
+Function TParser.TokenComponentIdent: String;
+
+begin
+end;
+
+
+Function TParser.TokenFloat: Extended;
+
+begin
+end;
+
+
+Function TParser.TokenInt: Longint;
+
+begin
+end;
+
+
+Function TParser.TokenString: string;
+
+begin
+end;
+
+
+Function TParser.TokenSymbolIs(const S: string): Boolean;
+
+begin
+end;
+{
+  $Log$
+  Revision 1.1  1998-05-04 14:30:12  michael
+  * Split file according to Class; implemented dummys for all methods, so unit compiles.
+
+}

fcl/inc/persist.inc

@@ -0,0 +1,63 @@
+{
+    $Id$
+    This file is part of the Free Component Library (FCL)
+    Copyright (c) 1998 by the Free Pascal development team
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+{****************************************************************************}
+{*                             TPersistent                                  *}
+{****************************************************************************}
+
+
+procedure TPersistent.AssignError(Source: TPersistent);
+begin
+end;
+
+
+
+procedure TPersistent.AssignTo(Dest: TPersistent);
+
+
+begin
+end;
+
+
+procedure TPersistent.DefineProperties(Filer: TFiler);
+
+begin
+end;
+
+
+function  TPersistent.GetOwner: TPersistent;
+
+begin
+end;
+
+destructor TPersistent.Destroy; 
+
+begin
+end;
+
+
+procedure TPersistent.Assign(Source: TPersistent);
+
+begin
+end;
+
+function  TPersistent.GetNamePath: string;
+
+begin
+end;
+{
+  $Log$
+  Revision 1.1  1998-05-04 14:30:12  michael
+  * Split file according to Class; implemented dummys for all methods, so unit compiles.
+
+}

fcl/inc/reader.inc

@@ -0,0 +1,362 @@
+{
+    $Id$
+    This file is part of the Free Component Library (FCL)
+    Copyright (c) 1998 by the Free Pascal development team
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+{****************************************************************************}
+{*                             TREADER                                      *}
+{****************************************************************************}
+
+Procedure TReader.CheckValue(Value: TValueType);
+
+begin
+end;
+
+
+
+Procedure TReader.DoFixupReferences;
+
+begin
+end;
+
+
+
+Procedure TReader.FreeFixups;
+
+begin
+end;
+
+
+
+Function TReader.GetPosition: Longint;
+
+begin
+end;
+
+
+
+Procedure TReader.PropertyError;
+
+begin
+end;
+
+
+
+Procedure TReader.ReadBuffer;
+
+begin
+end;
+
+
+
+Procedure TReader.ReadData(Instance: TComponent);
+
+begin
+end;
+
+
+
+Procedure TReader.ReadDataInner(Instance: TComponent);
+
+begin
+end;
+
+
+
+Procedure TReader.ReadProperty(AInstance: TPersistent);
+
+begin
+end;
+
+
+
+Procedure TReader.ReadPropValue(Instance: TPersistent; PropInfo: Pointer);
+
+begin
+end;
+
+
+
+Function TReader.ReadSet(SetType: Pointer): Integer;
+
+begin
+end;
+
+
+
+Procedure TReader.SetPosition(Value: Longint);
+
+begin
+end;
+
+
+
+Procedure TReader.SkipSetBody;
+
+begin
+end;
+
+
+
+Procedure TReader.SkipValue;
+
+begin
+end;
+
+
+
+Procedure TReader.SkipProperty;
+
+begin
+end;
+
+
+
+Procedure TReader.SkipComponent(SkipHeader: Boolean);
+
+begin
+end;
+
+
+
+Function TReader.Error(const Message: string): Boolean; 
+
+begin
+end;
+
+
+
+Function TReader.FindMethod(Root: TComponent; const MethodName: string): Pointer; 
+
+begin
+end;
+
+
+
+Procedure TReader.SetName(Component: TComponent; var Name: string); 
+
+begin
+end;
+
+
+
+Procedure TReader.ReferenceName(var Name: string); 
+
+begin
+end;
+
+
+
+Function TReader.FindAncestorComponent(const Name: string;
+  ComponentClass: TPersistentClass): TComponent; 
+
+begin
+end;
+
+
+
+destructor TReader.Destroy; 
+
+begin
+end;
+
+
+
+Procedure TReader.BeginReferences;
+
+begin
+end;
+
+
+
+Procedure TReader.DefineProperty(const Name: string;
+  rd : TReaderProc; wd : TWriterProc;
+  HasData: Boolean); 
+
+begin
+end;
+
+
+
+Procedure TReader.DefineBinaryProperty(const Name: string;
+  rd, wd: TStreamProc;
+  HasData: Boolean); 
+
+begin
+end;
+
+
+
+Function TReader.EndOfList: Boolean;
+
+begin
+end;
+
+
+
+Procedure TReader.EndReferences;
+
+begin
+end;
+
+
+
+Procedure TReader.FixupReferences;
+
+begin
+end;
+
+
+
+Procedure TReader.FlushBuffer; 
+
+begin
+end;
+
+
+
+Function TReader.NextValue: TValueType;
+
+begin
+end;
+
+
+
+Procedure TReader.Read(var Buf; Count: Longint);
+
+begin
+end;
+
+
+
+Function TReader.ReadBoolean: Boolean;
+
+begin
+end;
+
+
+
+Function TReader.ReadChar: Char;
+
+begin
+end;
+
+
+
+Procedure TReader.ReadCollection(Collection: TCollection);
+
+begin
+end;
+
+
+
+Function TReader.ReadComponent(Component: TComponent): TComponent;
+
+begin
+end;
+
+
+
+Procedure TReader.ReadComponents(AOwner, AParent: TComponent;
+  Proc: TReadComponentsProc);
+
+begin
+end;
+
+
+
+Function TReader.ReadFloat: Extended;
+
+begin
+end;
+
+
+
+Function TReader.ReadIdent: string;
+
+begin
+end;
+
+
+
+Function TReader.ReadInteger: Longint;
+
+begin
+end;
+
+
+
+Procedure TReader.ReadListBegin;
+
+begin
+end;
+
+
+
+Procedure TReader.ReadListEnd;
+
+begin
+end;
+
+
+
+Procedure TReader.ReadPrefix(var Flags: TFilerFlags; var AChildPos: Integer);
+
+begin
+end;
+
+
+
+Function TReader.ReadRootComponent(Root: TComponent): TComponent;
+
+begin
+end;
+
+
+
+Procedure TReader.ReadSignature;
+
+begin
+end;
+
+
+
+Function TReader.ReadStr: string;
+
+begin
+end;
+
+
+
+Function TReader.ReadString: string;
+
+begin
+end;
+
+
+
+Function TReader.ReadValue: TValueType;
+
+begin
+end;
+
+
+
+Procedure TReader.CopyValue(Writer: TWriter); {!!!}
+
+begin
+end;
+{
+  $Log$
+  Revision 1.1  1998-05-04 14:30:12  michael
+  * Split file according to Class; implemented dummys for all methods, so unit compiles.
+
+}

fcl/inc/streams.inc

@@ -0,0 +1,472 @@
+{
+    $Id$
+    This file is part of the Free Component Library (FCL)
+    Copyright (c) 1998 by the Free Pascal development team
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+{****************************************************************************}
+{*                             TStream                                      *}
+{****************************************************************************}
+
+  function TStream.GetPosition: Longint;
+
+    begin
+       GetPosition:=Seek(0,soFromCurrent);
+    end;
+
+  procedure TStream.SetPosition(Pos: Longint);
+
+    begin
+       Seek(soFromBeginning,Pos);
+    end;
+
+  function TStream.GetSize: Longint;
+
+    var
+       p : longint;
+
+    begin
+       p:=GetPosition;
+       GetSize:=Seek(soFromEnd,0);
+       Seek(soFromBeginning,p);
+    end;
+
+  procedure TStream.SetSize(NewSize: Longint);
+
+    begin
+       SetPosition(NewSize);
+    end;
+
+  procedure TStream.ReadBuffer(var Buffer; Count: Longint);
+
+    begin
+       if Read(Buffer,Count)<Count then
+{$ifdef NoExceptions}
+         ;
+{$else}
+         Raise(EReadError);
+{$endif}
+    end;
+
+  procedure TStream.WriteBuffer(const Buffer; Count: Longint);
+
+    begin
+       if Write(Buffer,Count)<Count then
+{$ifdef NoExceptions}
+         ;
+{$else}
+         Raise(EWriteError);
+{$endif}
+    end;
+
+  function TStream.CopyFrom(Source: TStream; Count: Longint): Longint;
+
+    var
+       i : longint;
+       buffer : array[0..1023] of byte;
+
+    begin
+       CopyFrom:=0;
+       while Count>0 do
+         begin
+            if (Count>sizeof(buffer)) then
+              i:=sizeof(Buffer)
+            else
+              i:=Count;
+            i:=Source.Read(buffer,i);
+            i:=Write(buffer,i);
+            dec(count,i);
+            CopyFrom:=CopyFrom+i;
+            if i=0 then
+              exit;
+         end;
+    end;
+
+  function TStream.ReadComponent(Instance: TComponent): TComponent;
+
+    var
+       Reader : TReader;
+
+    begin
+       Reader.Create(Self,1024);
+       if assigned(Instance) then
+         ReadComponent:=Reader.ReadRootComponent(Instance)
+       else
+         begin
+            {!!!!!}
+         end;
+       Reader.Destroy;
+    end;
+
+  function TStream.ReadComponentRes(Instance: TComponent): TComponent;
+
+    begin
+       {!!!!!}
+    end;
+
+  procedure TStream.WriteComponent(Instance: TComponent);
+
+    var
+       Writer : TWriter;
+
+    begin
+       Writer.Create(Self,1024);
+       Writer.WriteRootComponent(Instance);
+       Writer.Destroy;
+    end;
+
+  procedure TStream.WriteComponentRes(const ResName: string; Instance: TComponent);
+
+    var
+       startpos,s : longint;
+
+    begin
+(* 
+{$ifdef Win16Res}
+       { Numeric resource type }
+       WriteByte($ff);
+       { Application defined data }
+       WriteWord($0a);
+       { write the name as asciiz }
+       WriteData(ResName[1],length(ResName));
+       WriteByte(0);
+       { Movable, Pure and Discardable }
+       WriteWord($1030);
+       { size isn't known yet }
+       WriteDWord(0);
+       startpos:=GetPosition;
+       WriteComponent(Instance);
+       { calculate size }
+       s:=GetPosition-startpos;
+       { back patch size }
+       SetPosition(startpos-4);
+       WriteDWord(s);
+{$endif Win16Res}
+*)
+    end;
+
+  procedure TStream.WriteDescendent(Instance, Ancestor: TComponent);
+
+    begin
+       {!!!!!}
+    end;
+
+  procedure TStream.WriteDescendentRes(const ResName: string; Instance, Ancestor: TComponent);
+
+    begin
+       {!!!!!}
+    end;
+
+  procedure TStream.ReadResHeader;
+
+    begin
+{$ifdef Win16Res}
+       try
+         { application specific resource ? }
+         if ReadByte<>$ff then
+           raise EInvalidImage;
+         if ReadWord<>$000a then
+           raise EInvalidImage;
+         { read name }
+         while ReadByte<>0 do
+           ;
+         { check the access specifier }
+         if ReadWord<>$1030 then
+           raise EInvalidImage;
+         { ignore the size }
+         ReadDWord;
+       except
+{/////
+         on EInvalidImage do
+           raise;
+         else
+           raise(EInvalidImage);
+}
+       end;
+{$endif Win16Res}
+    end;
+
+  function TStream.ReadByte : Byte;
+
+    var
+       b : Byte;
+
+    begin
+       ReadBuffer(b,1);
+       ReadByte:=b;
+    end;
+
+  function TStream.ReadWord : Word;
+
+    var
+       w : Word;
+
+    begin
+       ReadBuffer(w,2);
+       ReadWord:=w;
+    end;
+
+  function TStream.ReadDWord : Cardinal;
+
+    var
+       d : Cardinal;
+
+    begin
+       ReadBuffer(d,4);
+       ReadDWord:=d;
+    end;
+
+  procedure TStream.WriteByte(b : Byte);
+
+    begin
+       WriteBuffer(b,1);
+    end;
+
+  procedure TStream.WriteWord(w : Word);
+
+    begin
+       WriteBuffer(w,2);
+    end;
+
+  procedure TStream.WriteDWord(d : Cardinal);
+
+    begin
+       WriteBuffer(d,4);
+    end;
+
+
+
+
+
+
+
+{****************************************************************************}
+{*                             THandleStream                                *}
+{****************************************************************************}
+
+Procedure THandleStream.SetSize(NewSize: Longint);
+
+begin
+end;
+
+
+Constructor THandleStream.Create(AHandle: Integer);
+
+begin
+end;
+
+
+function THandleStream.Read(var Buffer; Count: Longint): Longint;
+
+begin
+end;
+
+
+function THandleStream.Write(const Buffer; Count: Longint): Longint;
+
+begin
+end;
+
+
+function THandleStream.Seek(Offset: Longint; Origin: Word): Longint;
+
+begin
+end;
+
+
+{****************************************************************************}
+{*                             TFileStream                                  *}
+{****************************************************************************}
+
+constructor TFileStream.Create(const FileName: string; Mode: Word);
+
+begin
+end;
+
+
+destructor TFileStream.Destroy;
+
+begin
+end;
+
+{****************************************************************************}
+{*                             TCustomMemoryStream                          *}
+{****************************************************************************}
+
+procedure TCustomMemoryStream.SetPointer(Ptr: Pointer; Size: Longint);
+
+begin
+end;
+
+
+function TCustomMemoryStream.Read(var Buffer; Count: Longint): Longint;
+
+begin
+end;
+
+
+function TCustomMemoryStream.Seek(Offset: Longint; Origin: Word): Longint;
+
+begin
+end;
+
+
+procedure TCustomMemoryStream.SaveToStream(Stream: TStream);
+
+begin
+end;
+
+
+procedure TCustomMemoryStream.SaveToFile(const FileName: string);
+
+begin
+end;
+
+
+{****************************************************************************}
+{*                             TMemoryStream                                *}
+{****************************************************************************}
+
+
+procedure TMemoryStream.SetCapacity(NewCapacity: Longint);
+
+begin
+end;
+
+
+function TMemoryStream.Realloc(var NewCapacity: Longint): Pointer;
+
+begin
+end;
+
+
+destructor TMemoryStream.Destroy;
+
+begin
+end;
+
+
+procedure TMemoryStream.Clear;
+
+begin
+end;
+
+
+procedure TMemoryStream.LoadFromStream(Stream: TStream);
+
+begin
+end;
+
+
+procedure TMemoryStream.LoadFromFile(const FileName: string);
+
+begin
+end;
+
+
+procedure TMemoryStream.SetSize(NewSize: Longint);
+
+begin
+end;
+
+
+function TMemoryStream.Write(const Buffer; Count: Longint): Longint; 
+
+begin
+end;
+
+
+{****************************************************************************}
+{*                             TStringStream                                *}
+{****************************************************************************}
+
+procedure TStringStream.SetSize(NewSize: Longint); 
+
+begin
+end;
+
+
+constructor TStringStream.Create(const AString: string);
+
+begin
+end;
+
+
+function TStringStream.Read(var Buffer; Count: Longint): Longint; 
+
+begin
+end;
+
+
+function TStringStream.ReadString(Count: Longint): string;
+
+begin
+end;
+
+
+function TStringStream.Seek(Offset: Longint; Origin: Word): Longint; 
+
+begin
+end;
+
+
+function TStringStream.Write(const Buffer; Count: Longint): Longint; 
+
+begin
+end;
+
+
+procedure TStringStream.WriteString(const AString: string);
+
+begin
+end;
+
+
+
+{****************************************************************************}
+{*                             TResourceStream                              *}
+{****************************************************************************}
+
+procedure TResourceStream.Initialize(Instance: THandle; Name, ResType: PChar);
+
+begin
+end;
+
+
+constructor TResourceStream.Create(Instance: THandle; const ResName: string; ResType: PChar);
+
+begin
+end;
+
+
+constructor TResourceStream.CreateFromID(Instance: THandle; ResID: Integer; ResType: PChar);
+
+begin
+end;
+
+
+destructor TResourceStream.Destroy; 
+
+begin
+end;
+
+
+function TResourceStream.Write(const Buffer; Count: Longint): Longint; 
+
+begin
+end;
+
+
+{
+  $Log$
+  Revision 1.1  1998-05-04 14:30:12  michael
+  * Split file according to Class; implemented dummys for all methods, so unit compiles.
+
+}

fcl/inc/strings.inc

@@ -0,0 +1,468 @@
+{
+    $Id$
+    This file is part of the Free Component Library (FCL)
+    Copyright (c) 1998 by the Free Pascal development team
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+{****************************************************************************}
+{*                             TStrings                                     *}
+{****************************************************************************}
+
+
+function TStrings.GetCommaText: string;
+
+begin
+end;
+
+
+
+function TStrings.GetName(Index: Integer): string;
+
+begin
+end;
+
+
+
+Function TStrings.GetValue(const Name: string): string;
+
+begin
+end;
+
+
+
+Procedure TStrings.ReadData(Reader: TReader);
+
+begin
+end;
+
+
+
+Procedure TStrings.SetCommaText(const Value: string);
+
+begin
+end;
+
+
+
+Procedure TStrings.SetStringsAdapter(const Value: IStringsAdapter);
+
+begin
+end;
+
+
+
+Procedure TStrings.SetValue(const Name, Value: string);
+
+begin
+end;
+
+
+
+Procedure TStrings.WriteData(Writer: TWriter);
+
+begin
+end;
+
+
+
+Procedure TStrings.DefineProperties(Filer: TFiler); 
+
+begin
+end;
+
+
+
+Procedure TStrings.Error(const Msg: string; Data: Integer);
+
+begin
+end;
+
+
+
+Function TStrings.GetCapacity: Integer; 
+
+begin
+end;
+
+
+
+Function TStrings.GetObject(Index: Integer): TObject; 
+
+begin
+end;
+
+
+
+Function TStrings.GetTextStr: string; 
+
+begin
+end;
+
+
+
+Procedure TStrings.Put(Index: Integer; const S: string); 
+
+begin
+end;
+
+
+
+Procedure TStrings.PutObject(Index: Integer; AObject: TObject); 
+
+begin
+end;
+
+
+
+Procedure TStrings.SetCapacity(NewCapacity: Integer); 
+
+begin
+end;
+
+
+
+Procedure TStrings.SetTextStr(const Value: string); 
+
+begin
+end;
+
+
+
+Procedure TStrings.SetUpdateState(Updating: Boolean); 
+
+begin
+end;
+
+
+
+destructor TSTrings.Destroy; 
+
+begin
+end;
+
+
+
+Function TStrings.Add(const S: string): Integer; 
+
+begin
+end;
+
+
+
+Function TStrings.AddObject(const S: string; AObject: TObject): Integer; 
+
+begin
+end;
+
+
+
+Procedure TStrings.Append(const S: string);
+
+begin
+end;
+
+
+
+Procedure TStrings.AddStrings(TheStrings: TStrings); 
+
+begin
+end;
+
+
+
+Procedure TStrings.Assign(Source: TPersistent); 
+
+begin
+end;
+
+
+
+Procedure TStrings.BeginUpdate;
+
+begin
+end;
+
+
+
+Procedure TStrings.EndUpdate;
+
+begin
+end;
+
+
+
+Function TStrings.Equals(TheStrings: TStrings): Boolean;
+
+begin
+end;
+
+
+
+Procedure TStrings.Exchange(Index1, Index2: Integer); 
+
+begin
+end;
+
+
+
+Function TStrings.GetText: PChar; 
+
+begin
+end;
+
+
+
+Function TStrings.IndexOf(const S: string): Integer; 
+
+begin
+end;
+
+
+
+Function TStrings.IndexOfName(const Name: string): Integer;
+
+begin
+end;
+
+
+
+Function TStrings.IndexOfObject(AObject: TObject): Integer;
+
+begin
+end;
+
+
+
+Procedure TStrings.InsertObject(Index: Integer; const S: string;
+  AObject: TObject);
+
+begin
+end;
+
+
+
+Procedure TStrings.LoadFromFile(const FileName: string); 
+
+begin
+end;
+
+
+
+Procedure TStrings.LoadFromStream(Stream: TStream); 
+
+begin
+end;
+
+
+
+Procedure TStrings.Move(CurIndex, NewIndex: Integer); 
+
+begin
+end;
+
+
+
+Procedure TStrings.SaveToFile(const FileName: string); 
+
+begin
+end;
+
+
+
+Procedure TStrings.SaveToStream(Stream: TStream); 
+
+begin
+end;
+
+
+
+Procedure TStrings.SetText(TheText: PChar); 
+
+begin
+end;
+
+
+{****************************************************************************}
+{*                             TStringList                                  *}
+{****************************************************************************}
+
+
+
+Procedure TStringList.ExchangeItems(Index1, Index2: Integer);
+
+begin
+end;
+
+
+
+Procedure TStringList.Grow;
+
+begin
+end;
+
+
+
+Procedure TStringList.QuickSort(L, R: Integer);
+
+begin
+end;
+
+
+
+Procedure TStringList.InsertItem(Index: Integer; const S: string);
+
+begin
+end;
+
+
+
+Procedure TStringList.SetSorted(Value: Boolean);
+
+begin
+end;
+
+
+
+Procedure TStringList.Changed; 
+
+begin
+end;
+
+
+
+Procedure TStringList.Changing; 
+
+begin
+end;
+
+
+
+Function TStringList.Get(Index: Integer): string; 
+
+begin
+end;
+
+
+
+Function TStringList.GetCapacity: Integer; 
+
+begin
+end;
+
+
+
+Function TStringList.GetCount: Integer; 
+
+begin
+end;
+
+
+
+Function TStringList.GetObject(Index: Integer): TObject; 
+
+begin
+end;
+
+
+
+Procedure TStringList.Put(Index: Integer; const S: string); 
+
+begin
+end;
+
+
+
+Procedure TStringList.PutObject(Index: Integer; AObject: TObject); 
+
+begin
+end;
+
+
+
+Procedure TStringList.SetCapacity(NewCapacity: Integer); 
+
+begin
+end;
+
+
+
+Procedure TStringList.SetUpdateState(Updating: Boolean); 
+
+begin
+end;
+
+
+
+destructor TStringList.Destroy; 
+
+begin
+end;
+
+
+
+Function TStringList.Add(const S: string): Integer; 
+
+begin
+end;
+
+
+
+Procedure TStringList.Clear; 
+
+begin
+end;
+
+
+
+Procedure TStringList.Delete(Index: Integer); 
+
+begin
+end;
+
+
+
+Procedure TStringList.Exchange(Index1, Index2: Integer); 
+
+begin
+end;
+
+
+
+Function TStringList.Find(const S: string; var Index: Integer): Boolean; 
+
+begin
+end;
+
+
+
+Function TStringList.IndexOf(const S: string): Integer; 
+
+begin
+end;
+
+
+
+Procedure TStringList.Insert(Index: Integer; const S: string); 
+
+begin
+end;
+
+
+
+Procedure TStringList.Sort; 
+
+begin
+end;
+{
+  $Log$
+  Revision 1.1  1998-05-04 14:30:12  michael
+  * Split file according to Class; implemented dummys for all methods, so unit compiles.
+
+}

fcl/inc/thread.inc

@@ -0,0 +1,96 @@
+{
+    $Id$
+    This file is part of the Free Component Library (FCL)
+    Copyright (c) 1998 by the Free Pascal development team
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+{****************************************************************************}
+{*                             TThread                                      *}
+{****************************************************************************}
+
+
+procedure TThread.CallOnTerminate;
+
+begin
+end;
+
+
+function TThread.GetPriority: TThreadPriority;
+
+begin
+end;
+
+
+procedure TThread.SetPriority(Value: TThreadPriority);
+
+begin
+end;
+
+
+procedure TThread.SetSuspended(Value: Boolean);
+
+begin
+end;
+
+
+procedure TThread.DoTerminate; 
+
+begin
+end;
+
+
+procedure TThread.Synchronize(Method: TThreadMethod);
+
+begin
+end;
+
+
+constructor TThread.Create(CreateSuspended: Boolean);
+
+begin
+end;
+
+
+destructor TThread.Destroy;
+
+begin
+end;
+
+
+procedure TThread.Resume;
+
+begin
+end;
+
+
+procedure TThread.Suspend;
+
+begin
+end;
+
+
+procedure TThread.Terminate;
+
+begin
+end;
+
+
+function TThread.WaitFor: Integer;
+
+begin
+end;
+
+
+{
+  $Log$
+  Revision 1.1  1998-05-04 14:30:12  michael
+  * Split file according to Class; implemented dummys for all methods, so unit compiles.
+
+}

fcl/inc/writer.inc

@@ -0,0 +1,205 @@
+{
+    $Id$
+    This file is part of the Free Component Library (FCL)
+    Copyright (c) 1998 by the Free Pascal development team
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+{****************************************************************************}
+{*                             TWriter                                      *}
+{****************************************************************************}
+
+Procedure TWriter.AddAncestor(Component: TComponent);
+
+begin
+end;
+
+
+function  TWriter.GetPosition: Longint;
+
+begin
+end;
+
+
+Procedure TWriter.SetPosition(Value: Longint);
+
+begin
+end;
+
+
+Procedure TWriter.WriteBuffer;
+
+begin
+end;
+
+
+Procedure TWriter.WriteData(Instance: TComponent); 
+
+begin
+end;
+
+
+Procedure TWriter.WriteProperty(Instance: TPersistent; PropInfo: Pointer);
+
+begin
+end;
+
+
+Procedure TWriter.WriteProperties(Instance: TPersistent);
+
+begin
+end;
+
+
+Procedure TWriter.WritePropName(const PropName: string);
+
+begin
+end;
+
+
+Procedure TWriter.WriteBinary(wd : TStreamProc);
+
+begin
+end;
+
+
+Procedure TWriter.WritePrefix(Flags: TFilerFlags; AChildPos: Integer);
+
+begin
+end;
+
+
+Procedure TWriter.WriteValue(Value: TValueType);
+
+begin
+end;
+
+
+Destructor TWriter.Destroy; 
+
+begin
+end;
+
+
+Procedure TWriter.DefineProperty(const Name: string;
+  rd : TReaderProc; wd : TWriterProc;
+  HasData: Boolean); 
+
+begin
+end;
+
+
+Procedure TWriter.DefineBinaryProperty(const Name: string;
+  rd, wd: TStreamProc;
+  HasData: Boolean); 
+
+begin
+end;
+
+
+Procedure TWriter.FlushBuffer; 
+
+begin
+end;
+
+
+Procedure TWriter.Write(const Buf; Count: Longint);
+
+begin
+end;
+
+
+Procedure TWriter.WriteBoolean(Value: Boolean);
+
+begin
+end;
+
+
+Procedure TWriter.WriteCollection(Value: TCollection);
+
+begin
+end;
+
+
+Procedure TWriter.WriteComponent(Component: TComponent);
+
+begin
+end;
+
+
+Procedure TWriter.WriteChar(Value: Char);
+
+begin
+end;
+
+
+Procedure TWriter.WriteDescendent(Root: TComponent; AAncestor: TComponent);
+
+begin
+end;
+
+
+Procedure TWriter.WriteFloat(Value: Extended);
+
+begin
+end;
+
+
+Procedure TWriter.WriteIdent(const Ident: string);
+
+begin
+end;
+
+
+Procedure TWriter.WriteInteger(Value: Longint);
+
+begin
+end;
+
+
+Procedure TWriter.WriteListBegin;
+
+begin
+end;
+
+
+Procedure TWriter.WriteListEnd;
+
+begin
+end;
+
+
+Procedure TWriter.WriteRootComponent(Root: TComponent);
+
+begin
+end;
+
+
+Procedure TWriter.WriteSignature;
+
+begin
+end;
+
+
+Procedure TWriter.WriteStr(const Value: string);
+
+begin
+end;
+
+
+Procedure TWriter.WriteString(const Value: string);
+
+begin
+end;
+{
+  $Log$
+  Revision 1.1  1998-05-04 14:30:12  michael
+  * Split file according to Class; implemented dummys for all methods, so unit compiles.
+
+}