supermario/base/SuperMarioProj.1994-02-09/Toolbox/DataPubsMgr/dpMisc.inc.p
2019-06-29 23:17:50 +08:00

302 lines
9.0 KiB
OpenEdge ABL

{
File: dpMisc.inc.p
Written by: Nick Kledzik
Copyright: © 1989-1990 by Apple Computer, Inc., all rights reserved.
This file is used in these builds: BigBang
Change History (most recent first):
<13> 11/26/90 ngk <DFH> Add warning handlers FailNonWrn and IgnoreWrn.
Moved dp_GetCurrentAppRefNum to dpMisc.a
<12> 9/13/90 ngk Changed file type for edition files to be all lowercase.
<11> 7/16/90 RLC Change GetAppSignature routine to set info.processAppSpec to NIL
instead of .processFileName.
<10> 7/2/90 ngk Added IsEditionFile.
<9> 5/31/90 ngk Changed em globals from a handle to a pointer.
<8> 4/7/90 ngk Add dynamic array. Add new failure handlers.
<7> 3/10/90 ngk Removed GetStateAndLock and RestoreState. Added dpSameBytes.
<6> 3/4/90 ngk Fix bug in calling GetProcessInformation with setting up
processInfoLength field.
<5> 2/25/90 ngk Use SameProcess in dp_GetCurrentAppRefNum instead of comparing
bits. Changed GetCurrentAppSignature to GetAppSignature.
<4> 2/4/90 ngk Removed Desktop database routines
<3> 1/8/90 ngk renamed dp_GetCurrentAppRefNum
<2> 1/6/90 ngk Convert to BBS
To Do:
}
{ the following are actually in dpMisc.a }
PROCEDURE UnSignedDivide; EXTERNAL;
PROCEDURE UnSignedMultiply; EXTERNAL;
FUNCTION dpGetGlobalsLocation; EXTERNAL;
PROCEDURE dpSetCurrentAppRefNum(app: AppRefNum); EXTERNAL;
FUNCTION dp_GetCurrentAppRefNum(VAR app: AppRefNum): OSErr; EXTERNAL;
FUNCTION dp_CallEditionOpenerProc; EXTERNAL;
FUNCTION dp_CallFormatIOProc; EXTERNAL;
PROCEDURE FailOSErr; EXTERNAL;
FUNCTION IsFailure; EXTERNAL;
{------------- GetAppSignature -------------}
FUNCTION GetAppSignature(PSN: ProcessSerialNumber; VAR signature: OSType): OSErr;
VAR
info: ProcessInfoRec;
BEGIN
info.processInfoLength := SizeOf(info);
info.processName := NIL;
info.processAppSpec := NIL; {info.processFileName := NIL; This was the old way}
GetAppSignature := GetProcessInformation(PSN, info);
signature := info.processSignature;
END; { GetAppSignature }
{------------- RemoveAppsGlobals -------------}
PROCEDURE RemoveAppsGlobals(whichApp: AppRefNum); { called only by dp_QuitEditionPack }
VAR
prevAppGlobal: PerAppGlobalsHandle;
nextAppGlobal: PerAppGlobalsHandle;
globals: EdtnMgrGlobalsPtr;
BEGIN
globals := dpGetGlobalsLocation^;
IF globals = NIL THEN EXIT(RemoveAppsGlobals);
nextAppGlobal := globals^.perAppListHead;
IF nextAppGlobal = NIL THEN EXIT(RemoveAppsGlobals);
IF nextAppGlobal = whichApp THEN
BEGIN
{ is first in list }
dpGetGlobalsLocation^^.perAppListHead := nextAppGlobal^^.nextApp;
END ELSE
BEGIN
{ is not first in list }
REPEAT
prevAppGlobal := nextAppGlobal;
nextAppGlobal := prevAppGlobal^^.nextApp;
IF nextAppGlobal = NIL THEN
BEGIN
{ cant find??? }
{$IFC qCatchFailures }
DebugStr('RemoveAppsGlobals: cannot find app');
{$ENDC }
EXIT(RemoveAppsGlobals);
END;
UNTIL (nextAppGlobal = whichApp);
{ remove whichApp's globals from list }
prevAppGlobal^^.nextApp := nextAppGlobal^^.nextApp;
END;
{ clear switched expandmem global }
dpSetCurrentAppRefNum(NIL);
{ actually dispose of app's global memory }
DisposHandle(Handle(whichApp));
END; { RemoveAppsGlobals }
{------------- dpSameBytes -------------}
FUNCTION dpSameBytes(aPtr, bPtr: UNIV Ptr; byteCount: INTEGER): BOOLEAN;
TYPE
BytePtr = ^SignedByte;
VAR
i: INTEGER;
BEGIN
dpSameBytes := FALSE;
FOR i := (byteCount - 1) DOWNTO 0 DO
BEGIN
IF BytePtr(aPtr)^ <> BytePtr(bPtr)^
THEN EXIT(dpSameBytes);
aPtr := POINTER(ORD(aPtr) + 1);
bPtr := POINTER(ORD(bPtr) + 1);
END;
dpSameBytes := TRUE;
END; { dpSameBytes }
{------------- dpNewDynamicArray -------------}
FUNCTION dpNewDynamicArray(headerSize: Size; slotSize, initialSlots: INTEGER;
FUNCTION MyNewHandle(amount: Size): Handle;
VAR arrayH: DyanmicArrayHandle): OSErr;
VAR
initialSlotDataSize: Size;
arrayP: DyanmicArrayPtr;
BEGIN
UnSignedMultiply(slotSize, initialSlots, initialSlotDataSize);
arrayH := DyanmicArrayHandle(MyNewHandle(initialSlotDataSize + headerSize + SizeOf(DyanmicArray)) );
IF MemError = noErr THEN
BEGIN
arrayP := DyanmicArrayPtr( ORD(arrayH^) + headerSize );
arrayP^.slotSize := slotSize;
arrayP^.maxSlots := initialSlots;
arrayP^.lastUsedSlot := 0;
dpNewDynamicArray := noErr;
END ELSE
BEGIN
dpNewDynamicArray := MemError;
END;
END; { dpNewDynamicArray }
{------------- dpFindElement -------------}
FUNCTION dpFindElement(arrayH: DyanmicArrayHandle; headerSize: Size;
FUNCTION Matches(anEntryIndex: INTEGER; anEntryPtr: UNIV Ptr): BOOLEAN;
VAR foundIndex: INTEGER; VAR foundPtr: UNIV Ptr): BOOLEAN;
VAR
slotSize: INTEGER;
elemPtr: Ptr;
lastUsedSlot: INTEGER;
i: INTEGER;
BEGIN
elemPtr := POINTER( ORD(arrayH^) + headerSize );
lastUsedSlot := DyanmicArrayPtr(elemPtr)^.lastUsedSlot;
slotSize := DyanmicArrayPtr(elemPtr)^.slotSize;
elemPtr := POINTER( ORD(arrayH^) + headerSize + SizeOf(DyanmicArray) );
FOR i := 1 TO lastUsedSlot DO
BEGIN
IF Matches(i, elemPtr) THEN
BEGIN
foundIndex := i;
foundPtr := elemPtr;
dpFindElement := TRUE;
EXIT(dpFindElement);
END; {if}
elemPtr := POINTER( ORD(elemPtr) + slotSize );
END; {for}
dpFindElement := FALSE;
END; { dpFindElement }
{------------- dpGetDynamicArrayEntry -------------}
FUNCTION dpGetDynamicArrayEntry(arrayH: DyanmicArrayHandle; headerSize: Size;
entryIndex: INTEGER; VAR entryPtr: UNIV Ptr): OSErr;
VAR
arrayP: DyanmicArrayPtr;
newSlotOffset: Size;
BEGIN
arrayP := DyanmicArrayPtr( ORD(arrayH^) + headerSize );
UnSignedMultiply(arrayP^.slotSize, entryIndex-1, newSlotOffset);
entryPtr := Ptr( ORD(arrayP) + SizeOf(DyanmicArray) + newSlotOffset );
dpGetDynamicArrayEntry := noErr;
END; { dpGetDynamicArrayEntry }
{------------- dpAddDynamicArrayEntry -------------}
FUNCTION dpAddDynamicArrayEntry(arrayH: DyanmicArrayHandle; headerSize: Size;
VAR entryIndex: INTEGER; VAR entryPtr: UNIV Ptr): OSErr;
VAR
slotToUse: INTEGER;
maxSlots: INTEGER;
slotSize: INTEGER;
dummy: INTEGER;
arrayP: DyanmicArrayPtr;
newSlotDataSize:Size;
newSlotOffset: Size;
BEGIN
arrayP := DyanmicArrayPtr( ORD(arrayH^) + headerSize );
slotSize := arrayP^.slotSize;
slotToUse := arrayP^.lastUsedSlot + 1;
maxSlots := arrayP^.maxSlots;
IF slotToUse > maxSlots THEN
BEGIN
{$IFC qRangeCheck }
{ find how many slots there currently is }
UnSignedDivide(GetHandleSize(Handle(arrayH)) - SizeOf(DyanmicArray) - headerSize, {numer}
arrayP^.slotSize, {denom}
maxSlots, {quotient}
dummy); {remainder}
IF dummy <> 0 THEN DebugStr('dpAddDynamicArrayEntry: bad dynamic record size');
{$ENDC }
maxSlots := 2 * maxSlots; { double the number of slots }
UnSignedMultiply(slotSize, maxSlots, newSlotDataSize);
SetHandleSize(Handle(arrayH), headerSize + SizeOf(DyanmicArray) + newSlotDataSize);
IF MemError <> noErr THEN
BEGIN
dpAddDynamicArrayEntry := MemError;
EXIT(dpAddDynamicArrayEntry);
END; {if}
{ re-derefence handle }
arrayP := DyanmicArrayPtr( ORD(arrayH^) + headerSize );
arrayP^.maxSlots := maxSlots;
END; {if}
entryIndex := slotToUse;
arrayP^.lastUsedSlot:= slotToUse;
UnSignedMultiply(slotSize, slotToUse-1, newSlotOffset);
entryPtr := Ptr( ORD(arrayP) + SizeOf(DyanmicArray) + newSlotOffset );
dpAddDynamicArrayEntry := noErr;
END; { dpAddDynamicArrayEntry }
{------------- FailNonWrn -------------}
FUNCTION FailNonWrn(anErr: OSErr): OSErr;
BEGIN
IgnoreWrn(anErr);
FailNonWrn := anErr;
END; { FailNonWrn }
{------------- IgnoreWrn -------------}
PROCEDURE IgnoreWrn(anErr: OSErr);
BEGIN
IF (anErr <> noErr)
{&} THEN IF (anErr <> containerNotFoundWrn)
{&} THEN IF (anErr <> multiplePublisherWrn)
{&} THEN IF (anErr <> notThePublisherWrn)
{&} THEN IF (anErr <> userCanceledErr)
THEN FailOSErr(anErr);
END; { IgnoreWrn }
{------------- Success -------------}
PROCEDURE Success(VAR info: FailInfo);
BEGIN
{$IFC qRangeCheck}
IF dpGetGlobalsLocation^^.failureHandler <> @info
THEN DebugStr('Success: wrong FailInfo record');
{$ENDC}
dpGetGlobalsLocation^^.failureHandler := info.nextInfo;
END; { Success }
{------------- IsEditionFile -------------}
FUNCTION IsEditionFile(fdType: OSType): BOOLEAN;
BEGIN
IsEditionFile := TRUE;
IF LONGINT(fdType) <> LONGINT(kPICTEditionFileType)
{&} THEN IF LONGINT(fdType) <> LONGINT(kTEXTEditionFileType)
{&} THEN IF LONGINT(fdType) <> LONGINT(ksndEditionFileType)
{&} THEN IF LONGINT(fdType) <> LONGINT(kUnknownEditionFileType)
{&} THEN IF LONGINT(fdType) <> LONGINT('edtP') { grandfather in this type }
{&} THEN IF LONGINT(fdType) <> LONGINT('edtT') { grandfather in this type }
{&} THEN IF LONGINT(fdType) <> LONGINT('publ') { grandfather in this type }
THEN IsEditionFile := FALSE;
END; { IsEditionFile }