Implementation

Procedure InitDList;

Begin

if MaxAvail>=2*SizeOf(Element) then

begin

New(L.BegL);

New(L.EndL);

L.BegL^.Prev:=nil; L.BegL^.Next:=L.EndL;

L.EndL^.Prev:=L.BegL; L.EndL^.Next:=nil;

L.Ptr:=L.BegL;

error:=dlistok

end

else

begin

error:=dlistnotmem;

L.BegL:=nil; L.EndL:=nil;

L.Ptr:=nil

end

End;

Procedure PutPrev;

var p:ElPtr;

Begin

if L.Ptr<>L.BegL then

if SizeOf(Element)<=MaxAvail then

begin

New(p);

L.ptr:=L.Ptr^.Prev;

p^.Data:=E;

p^.Next:=L.Ptr^.Next;

p^.Prev:=L.Ptr;

L.Ptr^.Next^.Prev:=p;

L.Ptr^.Next:=p;

MoveNext(L);

error:=dlistok

end

else error:=dlistnotmem

else error:=dlistunder

End;

Procedure PutNext;

var p:ElPtr;

Begin

if L.Ptr<>L.EndL then

if SizeOf(Element)<=MaxAvail then

begin

New(p);

p^.Data:=E;

p^.Next:=L.Ptr^.Next;

p^.Prev:=L.Ptr;

L.Ptr^.Next^.Prev:=p;

L.Ptr^.Next:=p;

MoveNext(L);

error:=dlistok

end

else error:=dlistnotmem

else error:=dlistend

End;

Procedure GetPrev;

var p:ElPtr;

Begin

if (L.Ptr<>L.BegL) and (not Empty(L)) then

begin

if L.Ptr=L.BegL^.Next then MoveNext(L);

p:=L.Ptr^.Prev;

p^.Prev^.Next:=L.Ptr;

L.Ptr^.Prev:=p^.Prev;

E:=p^.Data;

Dispose(p)

end

else error:=dlistunder

End;

Procedure GetNext;

var p:ElPtr;

Begin

if (L.Ptr<>L.EndL) and (not Empty(L)) then

begin

if L.Ptr=L.EndL^.Prev then L.Ptr:=L.Ptr^.Prev;

p:=L.Ptr^.Next;

p^.Next^.Prev:=L.Ptr;

L.Ptr^.Next:=p^.Next;

E:=p^.Data;

Dispose(p)

end

else if Empty(L) then error:=dlistunder else error:=dlistend

End;

Procedure MovePrev;

Begin

if L.Ptr^.Prev<>nil then

begin

L.Ptr:=L.Ptr^.Prev;

error:=dlistok

end

else error:=dlistunder

End;

Procedure MoveNext;

Begin

if L.Ptr^.Next<>nil then

begin

L.Ptr:=L.Ptr^.Next;

error:=dlistok

end

else error:=dlistend

End;

Procedure BeginPtr;

Begin

L.Ptr:=L.BegL;

error:=dlistok

End;

Procedure EndPtr;

Begin

L.Ptr:=L.EndL;

error:=dlistok

End;

Function Empty;

Begin

Empty:=L.BegL^.Next=L.EndL

End;

Procedure DoneList;

var e:BaseType;

Begin

BeginPtr(L);

repeat

GetNext(L,e)

until error<>dlistok;

dispose(L.BegL);

dispose(L.EndL);

L.BegL:=nil;

L.EndL:=nil;

L.Ptr:=nil;

error:=dlistok

End;

End.

{------------------------------------------------------------------------------}

Unit UFifoM;{отображение очереди на массив}

Interface

Const fifook=0; {успешное завершение операции}

fifofull=1; {очередь переполнена}

fifoempty=2; {очередь пуста}

fifosize=20;

Type BaseType=byte;

Fifo=Record

Uk1,Uk2,n:byte;

Buf:array[0..FifoSize] of BaseType;

End;

Procedure InitFifo (var f:Fifo);{конструктор}

Function EmptyFifo (var f:Fifo):boolean;{очередь пуста?}

Function FullFifo (var f:Fifo):boolean;{очередь полна?}

Procedure GetFifo (var f:Fifo;var el:BaseType);{удаление элемента из очереди}

Procedure PutFifo (var f:Fifo; el:BaseType);{включение элемента в очередь}

Function ReadFifo(f:Fifo;el:BaseType):BaseType;{чтение первого элемента из очереди}