HugeArrayPrev()

word	HugeArrayPrev(
        void **		elemPtr1,				/* indicates current element */
        void **		elemPtr2,
        word * 		size);

This routine decrements a pointer to an element in a HugeArray to point to the previous element. If the element was the first element in its block, HugeArrayPrev() will unlock its block and lock the previous one. The routine writes the pointer to *elemPtr1, and writes a pointer to the first element in the block in *elemPtr2. It returns the number of elements which come before the newly-locked one in its block, counting the newly-locked element. If this routine is passed a pointer to the first element in a HugeArray, it returns zero and *elemPtr1 will point to the first element.

If the elements are variable-sized, then the word pointed to by size will be updated to reflect the size of the newly-locked element; otherwise, the value will be undefined.

Include: hugearr.h

Warnings: This routine may unlock the block containing the passed element. Therefore, if you need to mark the block as dirty, do so before making this call.

HugeArrayReplace()

void	HugeArrayReplace(
        VMFileHandle		file,
        VMBlockHandle		vmblock,				/* Handle of directory block */
        word		numElem,				/* # of elements to replace */
        dword		elemNum,				/* First element to replace */
        const void *		initData);				/* Copy this into each element

This routine replaces one or more elements with copies of the passed data. If initData is null, the elements will be filled with null bytes.

If the elements are of variable size, a single element will be resized; its new size will be numElem bytes long.

Include: hugearr.h

See Also: HugeArrayResize().

HugeArrayResize()

void	HugeArrayResize(
        VMFileHandle		vmFile,
        VMBlockHandle		vmBlock,			/* Handle of directory block */
        dword		elemNum,			/* Resize this element */
        word		newSize);			/* New size in bytes */

This routine resizes an element in a Huge Array. The array must contain variable-sized elements. If the new size is larger than the old, the extra space will be zero-initialized. If it is smaller, the element will be truncated.

Include: hugearr.h

HugeArrayUnlock()

void	HugeArrayUnlock(
        void *		elemPtr);

This routine unlocks the block of a HugeArray which contains the passed element.

Include: hugearr.h

Warnings: If you have changed any of the elements in the block, be sure to call HugeArrayDirty() before you unlock the block; otherwise the block might be discarded.

IACPConnect()

IACPConnection IACPConnect(
        GeodeToken 		*list, 
        IACPConnectFlags 		flags, 
        MemHandle 		appLaunchBlock, 
        optr 		client, 
        word 		*numServers);

This routine establishes a connection between a client object (by default the calling thread's application object) and one or more servers registered with the indicated list.

The client argument should be NullOptr unless the IACPCF_CLIENT_OD_SPECIFIED flag is set in the flags parameter.

Include: iacp.goh

IACPCreateDefaultLaunchBlock()

MemHandle IACPCreateDefaultLaunchBlock(
        word 		appMode);

This routine creates a memory block holding an AppLaunchBlock structure suitable for passing to IACPConnect() . The two valid values to pass in appMode are MSG_GEN_PROCESS_OPEN_APPLICATION and MSG_GEN_PROCESS_OPEN_ENGINE .

Include: iacp.goh

IACPFinishConnect()

void	IACPFinishConnect(
        IACPConnection		connection,
        optr		server);

Finishes a connection made to a server which had to change from non-interactible to interactible.

Include: iacp.goh

IACPGetServerNumber()

word	IACPGetServerNumber(
        IACPConnection		connection,
        optr		server);

This routine retrieves the server number for a particular server in a particular connection. It returns the server number.

Include: iacp.goh

IACPLostConnection()

void IACPLostConnection(
        optr 		oself, 
        IACPConnection 		connection);

This routine is called by IACP server objects to handle when a client closes a connection.

Include: iacp.goh