dos386c.c

arm-linux-gcc编译器

		RP_SET(rm_buffer_addr, 0, rm_seg);
		/*
		 * rm_address will be the protected pointer to that same buffer
		 */
		rm_address       = REAL_TO_PROT(rm_buffer_addr);
		rm_end_address   = (USHORT *) (((char *)rm_address) + REAL_BUFFER_SIZE*16);
		buffer_allocated = 1;
	}
	
	
	/* Get pointers to locations where passed by reference parameters 
	 * will be stored in the parameter passing buffer area.  The first
	 * parameter is always at rm_buffer (= rm_buffer_addr in real mode).
	 */

	/* NOTE: see comments under UDIPDisconnect for explanation of why
	 * we don't copy TermStruct even though it's an in parameter.
	 */
	SessionPtr = (UDISessionId _far *)((char _far *)rm_address + strlen(Configuration)+1);
	TIPIPCIdPtr = (UDIUInt32 _far *) (SessionPtr + sizeof(UDISessionId));
	
	if (BufferSizeCheck((FARPTR)(TIPIPCIdPtr + sizeof(UDIUInt32)),"UDIPConnect (1.3)")) {
		return UDIErrorIPCInternal;
	}

	/* Move input parameters which are passed by reference into paramter buffer area. */
	_fmemmove(rm_address,NEARPTR_TO_FARPTR(Configuration),strlen(Configuration)+1);

	/* Put actual parameters into packed structure for passing to real
	 * mode function.
	 */
	params.Configuration = rm_buffer_addr;
	params.Session       = PROT_TO_REAL((FARPTR)SessionPtr);
	params.TermStruct    = PROT_TO_REAL((FARPTR)TermStruct);
	params.DFEIPCId	     = DFEIPCId;
	params.TIPIPCId	     = PROT_TO_REAL(TIPIPCIdPtr);
	params.DFEVecRec     = PROT_TO_REAL((FARPTR)DFEVecRec);


	/* Call the real-mode function with the address of the function,
	 * the number of bytes in the packed structure and the address of
	 * the structure.
	 */

	ConnectErr = REALCALL(UDIConnectAddr,params);

	CheckRealError(ConnectErr,"UDIConnect (1.3)");

	/* Copy output parameters from parameter passing area back to protected space
	 */
	_fmemmove(NEARPTR_TO_FARPTR(Session),SessionPtr,sizeof(UDISessionId));
	_fmemmove(NEARPTR_TO_FARPTR(TIPIPCId),TIPIPCIdPtr,sizeof(UDIUInt32));

	return FUNC_VAL;


} /* UDIPConnect_13 */

#endif /* UDI13 */


#define TIPSTRLEN 80


UDIError CAT(UDIPCapabilities,UDI12FUNCVER) (
	REALPTR		UDICapabilitiesAddr,
	UDIUInt32	*TIPId,			/* Out */
	UDIUInt32	*TargetId,		/* Out */
	UDIUInt32	DFEId,			/* In */
	UDIUInt32	DFE,			/* In */
	UDIUInt32	*TIP,			/* Out */
	UDIUInt32	*DFEIPCId,		/* Out */
	UDIUInt32	*TIPIPCId,		/* Out */
	char		*TIPString		/* Out */
  	)
{
	UDIUInt32 _far	*TargetIdPtr;
	UDIUInt32 _far	*TIPPtr;
	UDIUInt32 _far	*DFEIPCIdPtr;
	UDIUInt32 _far	*TIPIPCIdPtr;
	UDIUInt32 _far	*TIPStringPtr;
	UDIUInt32 _far	*endPtr;
	UDIError 	Err;

	/* Structure for passing parameters to real mode function in TIP */
	_Packed struct {
		REALPTR		TIPId;
		REALPTR		TargetId;
		UDIUInt32	DFEId;
		UDIUInt32	DFE;
		REALPTR		TIP;
		REALPTR		DFEIPCId;
		REALPTR		TIPIPCId;
		REALPTR		TIPString;
	} params;


	/* Get pointers to locations where passed by reference parameters 
	 * will be stored in the parameter passing buffer area.  The first
	 * parameter is always at rm_address.
	 */

	TargetIdPtr = (UDIUInt32 _far *)((char _far *)rm_address + sizeof(UDIUInt32));
	TIPPtr = TargetIdPtr + sizeof(UDIUInt32);
	DFEIPCIdPtr = TIPPtr + sizeof(UDIUInt32);
	TIPIPCIdPtr = DFEIPCIdPtr + sizeof(UDIUInt32);
	TIPStringPtr = TIPIPCIdPtr + sizeof(UDIInt32);
	endPtr = TIPStringPtr + TIPSTRLEN;

	if (BufferSizeCheck((FARPTR)endPtr,"UDICapabilities" UDI12FUNCVERSTR,PRINT_ON)) {
		return UDIErrorIPCLimitation;		
	} /* if */
	
	/* Move parameters into paramter buffer area. */
	_fmemmove(rm_address,NEARPTR_TO_FARPTR(TIPId),sizeof(UDIUInt32));     
	_fmemmove(TargetIdPtr,NEARPTR_TO_FARPTR(TargetId),sizeof(UDIUInt32));
	_fmemmove(TIPPtr,NEARPTR_TO_FARPTR(TIP),sizeof(UDIUInt32));
	_fmemmove(DFEIPCIdPtr,NEARPTR_TO_FARPTR(DFEIPCId),sizeof(UDIUInt32));
	_fmemmove(TIPIPCIdPtr,NEARPTR_TO_FARPTR(TIPIPCId),sizeof(UDIInt32));
	_fmemmove(TIPStringPtr,NEARPTR_TO_FARPTR(TIPString),TIPSTRLEN);


	params.TIPId = rm_buffer_addr;
	params.TargetId = PROT_TO_REAL((FARPTR)TargetIdPtr);
	params.DFEId = DFEId;
	params.DFE = DFE;
	params.TIP = PROT_TO_REAL((FARPTR)TIPPtr);
	params.DFEIPCId = PROT_TO_REAL((FARPTR)DFEIPCIdPtr);
	params.TIPIPCId = PROT_TO_REAL((FARPTR)TIPIPCIdPtr);
	params.TIPString = PROT_TO_REAL((FARPTR)TIPStringPtr);


	Err = REALCALL(UDICapabilitiesAddr,params);

	CheckRealError(Err,"UDICapabilities" UDI12FUNCVERSTR);

	_fmemmove(NEARPTR_TO_FARPTR(TargetId),TargetIdPtr,sizeof(UDIUInt32));
	_fmemmove(NEARPTR_TO_FARPTR(TIP),TIPPtr,sizeof(UDIUInt32));
	_fmemmove(NEARPTR_TO_FARPTR(DFEIPCId),DFEIPCIdPtr,sizeof(UDIUInt32));
	_fmemmove(NEARPTR_TO_FARPTR(TIPIPCId),TIPIPCIdPtr,sizeof(UDIInt32));
	_fmemmove(NEARPTR_TO_FARPTR(TIPString),TIPStringPtr,TIPSTRLEN);
	_fmemmove(NEARPTR_TO_FARPTR(TIPId),(UDIUInt32 _far *)rm_address,sizeof(UDIUInt32));

	return FUNC_VAL;

}  /* UDIPCapabilities() */



#ifdef UDI13

/* UDI 1.3 version of UDIPCapabilities */
UDIError UDIPCapabilities_13 (
	REALPTR		UDICapabilitiesAddr,
	UDIUInt32	*TIPId,			/* Out */
	UDIUInt32	*TargetId,		/* Out */
	UDIUInt32	DFEId,			/* In */
	UDIUInt32	DFE,			/* In */
	UDIUInt32	*TIP,			/* Out */
	UDIUInt32	*DFEIPCId,		/* Out */
	UDIUInt32	*TIPIPCId,		/* Out */
	char		*TIPString,		/* Out */
	UDISizeT	BufSize,		/* In  1.3 */
	UDISizeT	*CountDone,		/* Out 1.3 */
	UDISessionId	connection_id
  	)
{
	UDIUInt32 _far	*TargetIdPtr;
	UDIUInt32 _far	*TIPPtr;
	UDIUInt32 _far	*DFEIPCIdPtr;
	UDIUInt32 _far	*TIPIPCIdPtr;
	UDIUInt32 _far	*TIPStringPtr;
	UDIUInt32 _far	*endPtr;
	UDISizeT	*CountDonePtr;
	UDIError 	ConnectErr;

	/* Structure for passing parameters to real mode function in TIP */
	_Packed struct {
		REALPTR		TIPId;
		REALPTR		TargetId;
		UDIUInt32	DFEId;
		UDIUInt32	DFE;
		REALPTR		TIP;
		REALPTR		DFEIPCId;
		REALPTR		TIPIPCId;
		REALPTR		TIPString;
		UDISizeT	BufSize;
		REALPTR		CountDone;
		UDISessionId	connection_id;
	} params;


	/* Get pointers to locations where passed by reference parameters 
	 * will be stored in the parameter passing buffer area.  The first
	 * parameter is always at rm_address.
	 */

	TargetIdPtr  = (UDIUInt32 _far *)((char _far *)rm_address + sizeof(UDIUInt32));
	TIPPtr       = TargetIdPtr + sizeof(UDIUInt32);
	DFEIPCIdPtr  = TIPPtr + sizeof(UDIUInt32);
	TIPIPCIdPtr  = DFEIPCIdPtr + sizeof(UDIUInt32);
	TIPStringPtr = TIPIPCIdPtr + sizeof(UDIInt32);
	CountDonePtr = (UDISizeT _far *) (TIPStringPtr + strlen(TIPString) + 1);
	endPtr       = (UDIUInt32 _far *) (CountDonePtr + sizeof(UDISizeT));

	if (BufferSizeCheck((FARPTR)endPtr,"UDICapabilities (1.3)",PRINT_ON) {
		return UDIErrorIPCLimitation;
	} /* if */

	
	/* Move parameters into paramter buffer area. */
	_fmemmove(rm_address,NEARPTR_TO_FARPTR(TIPId),sizeof(UDIUInt32));			/* TIPId */
	_fmemmove(TargetIdPtr, NEARPTR_TO_FARPTR(TargetId),sizeof(UDIUInt32));
	_fmemmove(TIPPtr, NEARPTR_TO_FARPTR(TIP),sizeof(UDIUInt32));
	_fmemmove(DFEIPCIdPtr, NEARPTR_TO_FARPTR(DFEIPCId),sizeof(UDIUInt32));
	_fmemmove(TIPIPCIdPtr, NEARPTR_TO_FARPTR(TIPIPCId),sizeof(UDIInt32));
	_fmemmove(TIPStringPtr, NEARPTR_TO_FARPTR(TIPString),strlen(TIPString)+1);
	_fmemmove(CountDonePtr, NEARPTR_TO_FARPTR(CountDone),sizeof(UDISizeT));


	params.TIPId         = rm_buffer_addr;
	params.TargetId      = PROT_TO_REAL((FARPTR)TargetIdPtr);
	params.DFEId         = DFEId;
	params.DFE           = DFE;
	params.TIP           = PROT_TO_REAL((FARPTR)TIPPtr);
	params.DFEIPCId      = PROT_TO_REAL((FARPTR)DFEIPCIdPtr);
	params.TIPIPCId      = PROT_TO_REAL((FARPTR)TIPIPCIdPtr);
	params.TIPString     = PROT_TO_REAL((FARPTR)TIPStringPtr);
	params.BufSize	     = BufSize;
	params.CountDone     = PROT_TO_REAL((FARPTR)CountDonePtr);
	params.connection_id = connection_id;


	ConnectErr = REALCALL(UDICapabilitiesAddr,params);

	CheckRealError(ConnectErr,"UDICapabilities (1.3)");


	_fmemmove(NEARPTR_TO_FARPTR(TIPId),     rm_address,   sizeof(UDIUInt32));
	_fmemmove(NEARPTR_TO_FARPTR(TargetId),  TargetIdPtr,  sizeof(UDIUInt32));
	_fmemmove(NEARPTR_TO_FARPTR(TIP),       TIPPtr,       sizeof(UDIUInt32));
	_fmemmove(NEARPTR_TO_FARPTR(DFEIPCId),  DFEIPCIdPtr,  sizeof(UDIUInt32));
	_fmemmove(NEARPTR_TO_FARPTR(TIPIPCId),  TIPIPCIdPtr,  sizeof(UDIInt32));
	_fmemmove(NEARPTR_TO_FARPTR(TIPString), TIPStringPtr, strlen(TIPString)+1);
	_fmemmove(NEARPTR_TO_FARPTR(CountDone), CountDonePtr, sizeof(CountDone));

	if (*CountDone <= BufSize)
		_fmemmove(NEARPTR_TO_FARPTR(TIPString),TIPStringPtr,*CountDone);
	else {
		_fmemmove(NEARPTR_TO_FARPTR(TIPString),TIPStringPtr,BufSize);
		SIZE_ERROR(*CountDone, BufSize, "UDIPCapabilities (1.3)");
	}



	return FUNC_VAL;

}  /* UDIPCapabilities_13() */

#endif /* UDI13 */


UDIError UDIPGetErrorMsg(
	REALPTR		UDIGetErrorMessageAddr,
	UDIError	ErrorCode,		/* In  */
	UDISizeT	MsgSize,		/* In  */
	char		*Msg,			/* Out */
	UDISizeT	*CountDone		/* Out */
	)
{
	UDIError	Err;
	UDISizeT _far	*CountDonePtr;
	long		Buffer_Adjustment;

	_Packed struct {
		UDIError	ErrorCode;
		UDISizeT	MsgSize;
		REALPTR		Msg;
		REALPTR		CountDone;
	} params;


	CountDonePtr = (UDISizeT _far *)(rm_address + MsgSize);

	if ((Buffer_Adjustment = BufferSizeCheck((FARPTR)(CountDonePtr + sizeof(UDISizeT)),"UDIPGetErrorMsg",PRINT_ON))) {
		if (MsgSize <= Buffer_Adjustment)
			return UDIErrorIPCLimitation;
		MsgSize -= Buffer_Adjustment;
	} /* if */

	/* Don't need to copy anything into the real mode parameter 
	 * buffer area for this call since there are no pointer "in"
	 * parameters.				     
	 */

	params.ErrorCode = ErrorCode;
	params.MsgSize   = MsgSize;
	params.Msg       = rm_buffer_addr;
	params.CountDone = PROT_TO_REAL((FARPTR)CountDonePtr);

	Err = REALCALL(UDIGetErrorMessageAddr,params);

	CheckRealError(Err,"UDIGetErrorMessage");

	_fmemmove(NEARPTR_TO_FARPTR(CountDone),CountDonePtr,sizeof(UDISizeT));
	if (*CountDone <= MsgSize)
		_fmemmove(NEARPTR_TO_FARPTR(Msg),rm_address,*CountDone);
	else {
		_fmemmove(NEARPTR_TO_FARPTR(Msg),rm_address,MsgSize);
		SIZE_ERROR(*CountDone, MsgSize, "UDIPGetErrorMessage");
	}
	
	return FUNC_VAL;

} /* UDIPGetErrorMessage */



UDIError UDIPSetCurrentConnection(
	REALPTR		UDISetCurrentConnectionAddr,
	UDISessionId	Session			/* In  */
	)
{
	UDIError	Err;

	Err = REALCALL(UDISetCurrentConnectionAddr,Session);

	CheckRealError(Err,"UDISetCurrentConnection");

	return FUNC_VAL;

} /* UDIPSetCurrentConnection() */



UDIError UDIPDisconnect(
	REALPTR		UDIDisconnectAddr,
	UDISessionId	Session,		/* In  */
	UDIBool		Terminate,		/* In  */
	DOSTerm _far	*TermStruct	/* In  */
	)
{
	UDIError	Err;
	DOSTerm         t;

	_Packed struct {
		UDISessionId	Session;
		UDIBool		Terminate;
		REALPTR		Term;
	} params;

	_fmemmove(NEARPTR_TO_FARPTR(&t),TermStruct,sizeof(TermStruct));

	/* The only pointer to be passed is a pointer to TermStruct
	 * but since TermStruct is already in real memory, we do
	 * not want to copy it (The TIP must store its registers into
	 * the original TermStruct, not the copy)
	 */

	/* For this call just need to pack everything into a structure,
	 * then do the call since there are no "out" parameters and no
	 * pointers to "in" parameters.
	 */
	params.Session   = Session;
	params.Terminate = Terminate;
	params.Term      = PROT_TO_REAL((FARPTR)TermStruct);	/* just convert to real */

	Err = REALCALL(UDIDisconnectAddr,params);

	CheckRealError(Err,"UDIDisconnect");

	return FUNC_VAL;

} /* UDIPDisconnect() */



UDIError UDIPGetTargetConfig(
	REALPTR		UDIGetTargetConfigAddr,
	UDIMemoryRange	KnownMemory[],		/* Out */
	UDIInt		*NumberOfRanges,	/* In/Out */
	UDIUInt32	ChipVersions[],		/* Out */
	UDIInt		*NumberOfChips		/* In/Out */
	)
{
	_Packed struct {
		REALPTR		KnownMemory;
		REALPTR		NumberOfRanges;
		REALPTR		ChipVersions;
		REALPTR		NumberOfChips;
	} params;

	UDIError		Err;
	UDIInt _far		*NumberOfRangesPtr;
	UDIUInt32 _far		*ChipVersionsPtr;
	UDIInt _far		*NumberOfChipsPtr;

	/* Get addresses in parameter passing buffer to store parameters
	 * which are passed-by-reference.
	 */
	 NumberOfRangesPtr = (UDIInt _far *) (rm_address + *NumberOfRanges * sizeof(UDIMemoryRange));
	 ChipVersionsPtr   = (UDIUInt32 _far *) (NumberOfRangesPtr + sizeof(UDIInt));
	 NumberOfChipsPtr  = (UDIInt _far *) (ChipVersionsPtr + *NumberOfChips * sizeof(UDIUInt32));



	if (BufferSizeCheck((FARPTR)(NumberOfChipsPtr + sizeof(UDIInt)),"UDIPGetTargetConfig",PRINT_ON)) {
		return UDIErrorIPCLimitation;
	} /* if */

	/* Copy parameters which are passed-by-reference to parameter
	 * passing buffer.  Only "In" data needs to be copied. 
	 */
	 _fmemmove(NumberOfRangesPtr,NEARPTR_TO_FARPTR(NumberOfRanges),sizeof(UDIInt));
	 _fmemmove(NumberOfChipsPtr,NEARPTR_TO_FARPTR(NumberOfChips),sizeof(UDIInt));

	/* Put data into packed structure. */
	params.KnownMemory    = rm_buffer_addr;
	params.NumberOfRanges = PROT_TO_REAL((FARPTR)NumberOfRangesPtr);
	params.ChipVersions   = PROT_TO_REAL((FARPTR)ChipVersionsPtr);
	params.NumberOfChips  = PROT_TO_REAL((FARPTR)NumberOfChipsPtr);

	Err = REALCALL(UDIGetTargetConfigAddr,params);

	CheckRealError(Err,"UDIGetTargetConfig");

	/* Put data back into protected mode program address. */
	_fmemmove(NEARPTR_TO_FARPTR(KnownMemory),rm_address,*NumberOfRanges * sizeof(UDIMemoryRange));
	_fmemmove(NEARPTR_TO_FARPTR(NumberOfRanges),NumberOfRangesPtr, sizeof(UDIInt));
	_fmemmove(NEARPTR_TO_FARPTR(ChipVersions), ChipVersionsPtr, *NumberOfChips * sizeof(UDIUInt32));
	_fmemmove(NEARPTR_TO_FARPTR(NumberOfChips), NumberOfChipsPtr, sizeof(UDIInt));

	return FUNC_VAL;

} /* UDIPGetTargetConfig() */



UDIError UDIPCreateProcess(
	REALPTR		UDICreateProcessAddr,
	UDIPId		*PId			/* Out */
	)
{
	UDIError	Err;


	if (BufferSizeCheck((FARPTR)(rm_address + sizeof(UDIPId)),"UDIPCreateProcess",PRINT_ON)) {