Section courante

A propos

Section administrative du site

  1. Unit Objects;
  2.  
  3. {$O+,F+,X+,I-,S-}
  4.  
  5. INTERFACE
  6.  
  7. Const
  8.  
  9. { Modes d'accès TStream }
  10.   stCreate    = $3C00;           { Créer un nouveau fichier }
  11.   stOpenRead  = $3D00;           { Accès en lecture uniquement }
  12.   stOpenWrite = $3D01;           { Accès en écriture uniquement }
  13.   stOpen      = $3D02;           { Accès en lecture et en écriture }
  14.  
  15. { Codes d'erreur TStream }
  16.  
  17.   stOk         =  0;              { Pas d'erreur }
  18.   stError      = -1;              { Erreur d'accès }
  19.   stInitError  = -2;              { Impossible d'initialiser le flux }
  20.   stReadError  = -3;              { Lecture au-delà de la fin du flux de données }
  21.   stWriteError = -4;              { Impossible d'étendre le flux de données }
  22.   stGetError   = -5;              { Obtenir un type d'objet non enregistré }
  23.   stPutError   = -6;              { Mettre de type d'objet non enregistré }
  24.  
  25. { Taille maximale de TCollection }
  26.  
  27.   MaxCollectionSize = 65520 div SizeOf(Pointer);
  28.  
  29. { Codes d'erreur TCollection }
  30.  
  31.   coIndexError = -1;              { Index hors intervalle }
  32.   coOverflow   = -2;              { Débordement }
  33.  
  34. { Taille d'entête VMT }
  35.  
  36.   vmtHeaderSize = 8;
  37.  
  38. Type
  39.  
  40. { Type des enregistrements de conversion }
  41.   WordRec=Record
  42.    Lo,Hi:Byte;
  43.   End;
  44.  
  45.   LongRec=Record
  46.    Lo,Hi:Word;
  47.   End;
  48.  
  49.   PtrRec=Record
  50.     Ofs,Seg:Word;
  51.   End;
  52.  
  53. { Pointeurs de chaîne de caractères }
  54.  
  55.   PString = ^String;
  56.  
  57. { Type d'ensemble de caractères }
  58.  
  59.   PCharSet = ^TCharSet;
  60.   TCharSet = Set of Char;
  61.  
  62. { Tableaux généraux }
  63.  
  64.   PByteArray = ^TByteArray;
  65.   TByteArray = Array[0..32767] of Byte;
  66.  
  67.   PWordArray = ^TWordArray;
  68.   TWordArray = Array[0..16383] of Word;
  69.  
  70. { Objet de base TObject }
  71.  
  72.   PObject = ^TObject;
  73.   TObject = Object
  74.    Constructor Init;
  75.    Procedure Free;
  76.    Destructor Done; Virtual;
  77.   End;
  78.  
  79. { TStreamRec }
  80.  
  81.   PStreamRec=^TStreamRec;
  82.   TStreamRec=Record
  83.    ObjType:Word;
  84.    VmtLink:Word;
  85.    Load:Pointer;
  86.    Store:Pointer;
  87.    Next:Word;
  88.   End;
  89.  
  90. { TStream }
  91.  
  92.   PStream=^TStream;
  93.   TStream=Object(TObject)
  94.    Status:Integer;
  95.    ErrorInfo: Integer;
  96.    Procedure CopyFrom(Var S:TStream;Count:Longint);
  97.    Procedure Error(Code,Info:Integer);Virtual;
  98.    Procedure Flush;Virtual;
  99.    Function Get:PObject;
  100.    Function GetPos:Longint; Virtual;
  101.    Function GetSize:Longint; Virtual;
  102.    Procedure Put(P:PObject);
  103.    Procedure Read(Var Buf;Count:Word);Virtual;
  104.    Function ReadStr:PString;
  105.    Procedure Reset;
  106.    Procedure Seek(Pos: Longint); Virtual;
  107.    Procedure Truncate; Virtual;
  108.    Procedure Write(Var Buf; Count: Word); Virtual;
  109.    Procedure WriteStr(P:PString);
  110.   End;
  111.  
  112. {Chaîne de caractères nom de fichier DOS }
  113.  
  114.   FNameStr = string[79];
  115.  
  116. { TDosStream }
  117.  
  118.   PDosStream=^TDosStream;
  119.   TDosStream=Object(TStream)
  120.    Handle:Word;
  121.    Constructor Init(FileName: FNameStr; Mode: Word);
  122.    Destructor Done; virtual;
  123.    Function GetPos:Longint; Virtual;
  124.    Function GetSize:Longint; Virtual;
  125.    Procedure Read(Var Buf;Count:Word);Virtual;
  126.    Procedure Seek(Pos:Longint);Virtual;
  127.    Procedure Truncate;Virtual;
  128.    Procedure Write(Var Buf;Count:Word);Virtual;
  129.   End;
  130.  
  131. { TBufStream }
  132.  
  133.   PBufStream = ^TBufStream;
  134.   TBufStream = Object(TDosStream)
  135.    Buffer: Pointer;
  136.    BufSize: Word;
  137.    BufPtr: Word;
  138.    BufEnd: Word;
  139.    Constructor Init(FileName:FNameStr;Mode,Size:Word);
  140.    Destructor Done; Virtual;
  141.    Procedure Flush; Virtual;
  142.    Function GetPos: Longint; Virtual;
  143.    Function GetSize: Longint; Virtual;
  144.    Procedure Read(Var Buf;Count:Word); Virtual;
  145.    Procedure Seek(Pos:Longint); Virtual;
  146.    Procedure Truncate; Virtual;
  147.    Procedure Write(Var Buf; Count:Word); Virtual;
  148.  End;
  149.  
  150. { TEmsStream }
  151.  
  152.   PEmsStream = ^TEmsStream;
  153.   TEmsStream = Object(TStream)
  154.     Handle:Word;
  155.     PageCount:Word;
  156.     Size:Longint;
  157.     Position:Longint;
  158.     Constructor Init(MinSize, MaxSize: Longint);
  159.     Destructor Done; Virtual;
  160.     Function GetPos:Longint; Virtual;
  161.     Function GetSize:Longint; Virtual;
  162.     Procedure Read(Var Buf; Count:Word); Virtual;
  163.     Procedure Seek(Pos:LongInt); Virtual;
  164.     Procedure Truncate; Virtual;
  165.     Procedure Write(Var Buf; Count:Word);Virtual;
  166.   End;
  167.  
  168. { Types TCollection }
  169.  
  170.   PItemList = ^TItemList;
  171.   TItemList = Array[0..MaxCollectionSize - 1] of Pointer;
  172.  
  173. { Objet TCollection }
  174.  
  175.   PCollection = ^TCollection;
  176.   TCollection = Object(TObject)
  177.    Items:PItemList;
  178.    Count:Integer;
  179.    Limit:Integer;
  180.    Delta:Integer;
  181.    Constructor Init(ALimit,ADelta:Integer);
  182.    Constructor Load(Var S:TStream);
  183.    Destructor Done; Virtual;
  184.    Function At(Index:Integer): Pointer;
  185.    Procedure AtDelete(Index:Integer);
  186.    Procedure AtFree(Index:Integer);
  187.    Procedure AtInsert(Index:Integer; Item:Pointer);
  188.    Procedure AtPut(Index:Integer; Item:Pointer);
  189.    Procedure Delete(Item:Pointer);
  190.    Procedure DeleteAll;
  191.    Procedure Error(Code,Info:Integer); Virtual;
  192.    Function FirstThat(Test:Pointer):Pointer;
  193.    Procedure ForEach(Action:Pointer);
  194.    Procedure Free(Item:Pointer);
  195.    Procedure FreeAll;
  196.    Procedure FreeItem(Item:Pointer); Virtual;
  197.    Function GetItem(Var S:TStream): Pointer; Virtual;
  198.    Function IndexOf(Item:Pointer): Integer; Virtual;
  199.    Procedure Insert(Item:Pointer); Virtual;
  200.    Function LastThat(Test:Pointer):Pointer;
  201.    Procedure Pack;
  202.    Procedure PutItem(Var S:TStream; Item:Pointer); Virtual;
  203.    Procedure SetLimit(ALimit:Integer); Virtual;
  204.    Procedure Store(Var S: TStream);
  205.   End;
  206.  
  207. { Objet TSortedCollection }
  208.  
  209.   PSortedCollection=^TSortedCollection;
  210.   TSortedCollection=Object(TCollection)
  211.    Duplicates:Boolean;
  212.    Constructor Load(var S:TStream);
  213.    Function Compare(Key1,Key2: Pointer): Integer; Virtual;
  214.    Function IndexOf(Item:Pointer): Integer; Virtual;
  215.    Procedure Insert(Item:Pointer); Virtual;
  216.    Function KeyOf(Item:Pointer):Pointer; Virtual;
  217.    Function Search(Key:Pointer;Var Index:Integer):Boolean; Virtual;
  218.    Procedure Store(Var S:TStream);
  219.   End;
  220.  
  221. { Objet TStringCollection }
  222.  
  223.   PStringCollection=^TStringCollection;
  224.   TStringCollection=Object(TSortedCollection)
  225.    Function Compare(Key1,Key2:Pointer):Integer;Virtual;
  226.    Procedure FreeItem(Item:Pointer);Virtual;
  227.    Function GetItem(Var S:TStream):Pointer; Virtual;
  228.    Procedure PutItem(Var S:TStream;Item:Pointer); Virtual;
  229.   End;
  230.  
  231. { Objet TResourceCollection }
  232.  
  233.   PResourceCollection=^TResourceCollection;
  234.   TResourceCollection=Object(TStringCollection)
  235.    Procedure FreeItem(Item:Pointer);Virtual;
  236.    Function GetItem(Var S:TStream):Pointer; Virtual;
  237.    Function KeyOf(Item:Pointer):Pointer; Virtual;
  238.    Procedure PutItem(Var S:TStream;Item:Pointer); Virtual;
  239.   End;
  240.  
  241. { Objet TResourceFile }
  242.  
  243.   PResourceFile = ^TResourceFile;
  244.   TResourceFile=Object(TObject)
  245.     Stream:PStream;
  246.     Modified:Boolean;
  247.     Constructor Init(AStream:PStream);
  248.     Destructor Done; Virtual;
  249.     Function Count: Integer;
  250.     Procedure Delete(Key:String);
  251.     Procedure Flush;
  252.     Function Get(Key:String):PObject;
  253.     Function KeyAt(I:Integer):String;
  254.     Procedure Put(Item:PObject;Key:String);
  255.     Function SwitchTo(AStream:PStream; Pack:Boolean):PStream;
  256.   End;
  257.  
  258. { Objet TStringList }
  259.  
  260.   TStrIndexRec=Record
  261.    Key,Count,Offset:Word;
  262.   End;
  263.  
  264.   PStrIndex=^TStrIndex;
  265.   TStrIndex=Array[0..9999] of TStrIndexRec;
  266.  
  267.   PStringList=^TStringList;
  268.   TStringList=Object(TObject)
  269.    Constructor Load(Var S:TStream);
  270.    Destructor Done;Virtual;
  271.    Function Get(Key:Word):String;
  272.   End;
  273.  
  274. { Objet TStrListMaker }
  275.   PStrListMaker = ^TStrListMaker;
  276.   TStrListMaker = object(TObject)
  277.     Constructor Init(AStrSize,AIndexSize:Word);
  278.     Destructor Done;Virtual;
  279.     Procedure Put(Key:Word;S:String);
  280.     Procedure Store(Var S:TStream);
  281.   End;
  282.  
  283. { Objet TPoint }
  284.  
  285.   TPoint = Object
  286.    X,Y:Integer;
  287.   End;
  288.  
  289. { Objet Rectangle }
  290.  
  291.   TRect = Object
  292.     A,B:TPoint;
  293.     Procedure Assign(XA,YA,XB,YB:Integer);
  294.     Procedure Copy(R:TRect);
  295.     Procedure Move(ADX,ADY:Integer);
  296.     Procedure Grow(ADX,ADY:Integer);
  297.     Procedure Intersect(R:TRect);
  298.     Procedure Union(R:TRect);
  299.     Function Contains(P:TPoint):Boolean;
  300.     Function Equals(R:TRect):Boolean;
  301.     Function Empty:Boolean;
  302.   End;
  303.  
  304. { Routines de gestion dynamique des chaînes de caractères }
  305. Function NewStr(Const S:String):PString;
  306. Procedure DisposeStr(P:PString);
  307.  
  308. { Routines LongInt }
  309. Function LongMul(X,Y:Integer):Longint;Inline($5A/$58/$F7/$EA);
  310. Function LongDiv(X:Longint;Y:Integer):Integer;Inline($59/$58/$5A/$F7/$F9);
  311.  
  312. { Routines de flux de données }
  313. Procedure RegisterType(Var S: TStreamRec);
  314.  
  315. { Procédure de notification d'abrégé }
  316. Procedure Abstract;
  317.  
  318. { Procédure d'enregistrement des objets }
  319. Procedure RegisterObjects;
  320.  
  321. Const
  322. { Procédure d'erreur de flux de données }
  323.  
  324.   StreamError: Pointer = nil;
  325.  
  326. { Variables d'état du flux de données EMS }
  327.  
  328.   EmsCurHandle:Word=$FFFF;
  329.   EmsCurPage:Word=$FFFF;
  330.  
  331. { Enregistrements d'enregistrement de flux de données }
  332.  
  333. Const
  334.   RCollection: TStreamRec = (
  335.     ObjType: 50;
  336.     VmtLink: Ofs(TypeOf(TCollection)^);
  337.     Load: @TCollection.Load;
  338.     Store: @TCollection.Store);
  339.  
  340. Const
  341.   RStringCollection: TStreamRec = (
  342.     ObjType: 51;
  343.     VmtLink: Ofs(TypeOf(TStringCollection)^);
  344.     Load: @TStringCollection.Load;
  345.     Store: @TStringCollection.Store);
  346.  
  347. Const
  348.   RStringList: TStreamRec = (
  349.     ObjType: 52;
  350.     VmtLink: Ofs(TypeOf(TStringList)^);
  351.     Load: @TStringList.Load;
  352.     Store: nil);
  353.  
  354. Const
  355.   RStrListMaker: TStreamRec = (
  356.     ObjType: 52;
  357.     VmtLink: Ofs(TypeOf(TStrListMaker)^);
  358.     Load: nil;
  359.     Store: @TStrListMaker.Store);


Dernière mise à jour : Dimanche, le 20 avril 2014