All Databases MacTech Vol 13-1997

Apr 97 Dialog Box

Volume Number: 13

Issue Number: 4

Column Tag: Dialog Box

Dialog Box

Bolo is a PBRead Completion Routine

Dear Editor,

I was pleased to see the article in MacTech December 1996 encouraging programmers

to use asynchronous I/O, but unfortunately some of the details in the article were not

correct. Richard Clark wrote "The completion routine for PBRead is especially poor,

as it receives no parameters... This routine appears to have A5 set up for it...

Firstly, the PBRead completion routine does get passed a parameter (a pointer to the

parameter block that has just completed) and secondly, A5 is not guaranteed to be set

up to point at your globals. A5 will be pointing to the globals of whichever application

was interrupted to execute the completion routine (which might even be your own

application, which is why A5 may sometimes appear to be set up correctly). If your

completion routine tries to access your program's globals without first making sure to

set up A5 correctly, the Mac will crash.

Fortunately, there's no problem as long as you know how to deal with it: Because the

PBRead completion routine gets passed a pointer to the parameter block, you can use

this to pass it as many extra parameters as you like.

1. Define a new "extended" PBRead parameter block like this

typedef struct
{
ioParam io;
void *regA5;
short my_parameter;

// ... and, so on, as many as you like

} ex_ioParam;

2. Before you call PBRead, fill in the parameters that you want the completion

routine to get (especially the Register A5 value).

static ex_ioParam pb; pb.io.ioCompletion = CompletionRoutine;

pb.io.ioRefNum = refnum;

// ... and so on

pb.regA5 = GetGlobalsRegister();

PBRead((ParmBlkPtr)&pb,TRUE);

3. In the completion routine, set up the correct A5 value and access other

parameters as necessary:

static void CompletionRoutine(void)

{

oldGlobalsReg

= SetGlobalsRegister(pb->regA5);

// ... Do your stuff

SetGlobalsRegister(oldGlobalsReg);

}

If you don't already have the 68K register accessor functions defined, they are:

#pragma parameter __D0 GetRegisterD0() // MOVEA.L D0,D0 local void*

GetRegisterD0(void)

= { 0x2000 };

#pragma parameter __A0 GetRegisterA4() // MOVEA.L A4,A0 local void*

GetRegisterA4(void)

= { 0x204C };

#pragma parameter __A0 GetRegisterA5() // MOVEA.L A5,A0 local void*

GetRegisterA5(void)

= { 0x204D };

#pragma parameter __A0 SetRegisterA4(__A0) // EXG A0,A4 local

void* SetRegisterA4(void*) = { 0xC14C };

#pragma parameter __A0 SetRegisterA5(__A0) // EXG A0,A5 local

void* SetRegisterA5(void*) = { 0xC14D };
#ifdef THINK_C

#if __option(a4_globals)

#define A4GLOBALS

#endif

#ifdef __MWERKS__

#if !__A5__

#define A4GLOBALS

#endif

#ifdef A4GLOBALS

#define GetGlobalsRegister GetRegisterA4

#define SetGlobalsRegister SetRegisterA4

#else

#define GetGlobalsRegister GetRegisterA5

#define SetGlobalsRegister SetRegisterA5

#endif

You can do a hell of a lot with completion routines, as long as you don't try to call

QuickDraw, the Memory Manager, or make synchronous calls. The entire game of Bolo

is basically one huge completion routine, which is why you can switch to Microsoft

Word, pull down a menu, and sit there holding the mouse button down, without

affecting the game of Bolo at all. That's why I've never really understood all the people

who continuously complain that the Mac needs preemptive multi-tasking. Sure,

preemptive multi-tasking makes the programming easier, but it doesn't

fundamentally change what you can do. In fact it makes some things worse - with

asynchronous I/O your completion routine gets called immediately when the operation

is complete, where as with preemptive multi-tasking you're at the mercy of some

scheduler that decides when your code next deserves to get a slice of CPU time.

Stuart Cheshire,cheshire@cs.stanford.edu

The Guiding Light

Not sure if I'm the first to point this out to you, but... I'm just looking at the "MacTech

Now" ad on page 77 of the February issue. I see shadows behind the logo text at the top.

And... The shadows don't match up! The ones behind the letters of the word "MacTech

indicate a light source above and to the left, but the ones behind the word "Now!

indicates a light source that's above and to the right!

Lawrence D'Oliveiro

Actually, Lawrence, the MacTechNOW logo was developed using an as yet unreleased

QuickDraw3D derivative technology called QuickDrawMPV. This technology allows the

simultaneous use of multiple points of view, resulting in shadows going in more than

one direction. We chose to use QuickDrawMPV because it best represents how the

MacTechNOW site provides information from more than one source.

We hope to offer more information about QuickDrawMPV in a future issue, assuming

Apple doesn't see this technology as the joke it really is and refuse to acknowledge its

existance.

Thanks for your note; I really wanted something like this for April, and you provided

it. :-)

Eric Gundrum, Editor-in-Chief