dos386c.c

arm-linux-gcc编译器

	_Packed struct {
		UDIResource	Addr;
		UDIInt32	PassCount;
		UDIBreakType	Type;
		REALPTR		BreakId;
	} params;

	if (BufferSizeCheck((FARPTR)(rm_address + sizeof(UDIBreakId)),"UDIPSetBreakpoint",PRINT_ON)) {
		return UDIErrorIPCLimitation;
	} /* if */

	/* Since only "out" parameters are passed by reference, don't
	 * need to copy anything into the parameter passing buffer before
	 * the call.  
	 */
	params.Addr      = Addr;
	params.PassCount = PassCount;
	params.Type      = Type;
	params.BreakId   = rm_buffer_addr;

	Err = REALCALL(UDISetBreakpointAddr,params);

	CheckRealError(Err,"UDISetBreakpoint");

	/* Need to copy "out" parameter data back into protected mode
	 * address space. 
	 */
	_fmemmove(NEARPTR_TO_FARPTR(BreakId),rm_address,sizeof(UDIBreakId));

	return FUNC_VAL;

} /* UDIPSetBreakpoint() */



UDIError UDIPQueryBreakpoint(
	REALPTR		UDIQueryBreakpointAddr,
	UDIBreakId	BreakId,		/* In  */
	UDIResource	*Addr,			/* Out */
	UDIInt32	*PassCount,		/* Out */
	UDIBreakType	*Type,			/* Out */
	UDIInt32	*CurrentCount		/* Out */
	)
{
	UDIError		Err;
	UDIInt32 _far		*PassCountPtr;
	UDIBreakType _far	*TypePtr;
	UDIInt32 _far		*CurrentCountPtr;

	_Packed struct {
		UDIBreakId	BreakId;
		REALPTR		Addr;
		REALPTR		PassCount;
		REALPTR		Type;
		REALPTR		CurrentCount;
	} params;

	/* Since all passed-by-reference variables are "out", don't need
	 * to copy data to parameter passing buffer.  Do need to set up
	 * pointers for real-mode function to use though.
	 */
	PassCountPtr    = (UDIInt32 _far *) (rm_address + sizeof(UDIResource));
	TypePtr         = (UDIBreakType _far *) (PassCountPtr + sizeof(UDIInt32));
	CurrentCountPtr = (UDIInt32 _far *) (TypePtr + sizeof(UDIBreakType));

	if (BufferSizeCheck((FARPTR)(CurrentCountPtr + sizeof(UDIBreakType)),"UDIPQueryBreakpoint",PRINT_ON)) {
		return UDIErrorIPCLimitation;
	} /* if */

	params.BreakId      = BreakId;
	params.Addr         = rm_buffer_addr;
	params.PassCount    = PROT_TO_REAL((FARPTR)PassCountPtr);
	params.Type         = PROT_TO_REAL((FARPTR)TypePtr);
	params.CurrentCount = PROT_TO_REAL((FARPTR)CurrentCountPtr);

	Err = REALCALL(UDIQueryBreakpointAddr,params);

	CheckRealError(Err,"UDIQueryBreakpoint");

	/* Copy returned values back into protected mode variables. */
	_fmemmove(NEARPTR_TO_FARPTR(Addr),rm_address,sizeof(UDIResource));
	_fmemmove(NEARPTR_TO_FARPTR(PassCount),PassCountPtr,sizeof(UDIInt32));
	_fmemmove(NEARPTR_TO_FARPTR(Type),TypePtr,sizeof(UDIBreakType));
	_fmemmove(NEARPTR_TO_FARPTR(CurrentCount),CurrentCountPtr,sizeof(UDIInt32));

	return FUNC_VAL;

} /* UDIPQueryBreakpoint() */



UDIError UDIPClearBreakpoint(
	REALPTR		UDIClearBreakpointAddr,
	UDIBreakId	BreakId			/* In  */
	)
{
	UDIError	Err;

	/* Don't need packed structure since only one parameter is passed. */

	Err = REALCALL(UDIClearBreakpointAddr,BreakId);

	CheckRealError(Err,"UDIClearBreakpoint");

	return FUNC_VAL;

} /* UDIPClearBreakpoint() */




UDIError UDIPGetStdout(
	REALPTR		UDIGetStdoutAddr,
	UDIHostMemPtr	Buf,			/* Out */
	UDISizeT	BufSize,		/* In  */
	UDISizeT	*CountDone		/* Out */
	)
{
	UDIError	Err;
	UDISizeT _far	*CountDonePtr;

	char *		CurrentTo;
	UDISizeT	TotalDone = 0;
	UDISizeT	CurrentCount;
	UDISizeT	CurrentDone = 0;
	long		BufAdjust;

	_Packed struct {
		REALPTR		Buf;
		UDISizeT	BufSize;
		REALPTR		CountDone;
	} params;

	CurrentCount = BufSize;
	CurrentTo    = (char *) Buf;

	do {
		CountDonePtr = (UDISizeT _far *) (rm_address + CurrentCount);

		BufAdjust = BufferSizeCheck((FARPTR)(CountDonePtr + sizeof(UDISizeT)),"UDIPGetStdout",PRINT_ON);
		if (BufAdjust) {
			CurrentCount = (rm_end_address - rm_address - sizeof(UDISizeT));
			CountDonePtr = (UDISizeT _far * ) (rm_end_address - sizeof(UDISizeT));
		} /* if */

		params.Buf       = rm_buffer_addr;
		params.BufSize   = CurrentCount;
		params.CountDone = PROT_TO_REAL((FARPTR)CountDonePtr);

		Err = REALCALL(UDIGetStdoutAddr,params);

		CheckRealError(Err,"UDIGetStdout");

		/* Copy returned values back into protected mode variables. */
		_fmemmove(NEARPTR_TO_FARPTR(&CurrentDone),CountDonePtr,sizeof(UDISizeT));

		TotalDone += CurrentDone;

		if (CurrentDone <= CurrentCount) 
			_fmemmove(NEARPTR_TO_FARPTR(CurrentTo),rm_address,CurrentDone);
		else {
			_fmemmove(NEARPTR_TO_FARPTR(CurrentTo),rm_address,CurrentDone);
			SIZE_ERROR(*CountDone, BufSize, "UDIPGetStdout");
		}

		/* Update looping variables for possible next pass */
		CurrentTo += CurrentDone;


	} while ((TotalDone < BufSize) & (CurrentDone == CurrentCount) 
		& (FUNC_VAL == UDINoError));

	*CountDone = TotalDone;

	return FUNC_VAL;

} /* UDIPGetStdout() */



UDIError UDIPGetStderr(
	REALPTR		UDIGetStderrAddr,
	UDIHostMemPtr	Buf,			/* Out */
	UDISizeT	BufSize,		/* In  */
	UDISizeT	*CountDone		/* Out */
	)
{
	UDIError	Err;
	UDISizeT _far	*CountDonePtr;
	long		Buffer_Adjustment;

	_Packed struct {
		REALPTR		Buf;
		UDISizeT	BufSize;
		REALPTR		CountDone;
	} params;

	/* Since all passed-by-reference variables are "out", don't need
	 * to copy data to parameter passing buffer.  Do need to set up
	 * pointers for real-mode function to use though.
	 */
	CountDonePtr = (UDISizeT _far *) (rm_address + BufSize);

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

	params.Buf       = rm_buffer_addr;
	params.BufSize   = BufSize;
	params.CountDone = PROT_TO_REAL((FARPTR)CountDonePtr);

	Err = REALCALL(UDIGetStderrAddr,params);

	CheckRealError(Err,"UDIGetStderr");

	/* Copy returned values back into protected mode variables. */
	_fmemmove(NEARPTR_TO_FARPTR(CountDone),CountDonePtr,sizeof(UDISizeT));
	if (*CountDone <= BufSize)
		_fmemmove(NEARPTR_TO_FARPTR(Buf),rm_address,*CountDone);
	else {
		_fmemmove(NEARPTR_TO_FARPTR(Buf),rm_address,BufSize);
		SIZE_ERROR(*CountDone, BufSize, "UDIPGetStderr");
	}

	return FUNC_VAL;
	
} /* UDIPGetStderr() */



UDIError UDIPPutStdin(
	REALPTR		UDIPutStdinAddr,
	UDIHostMemPtr	Buf,			/* In  */
	UDISizeT	Count,			/* In  */
	UDISizeT	*CountDone		/* Out */
	)
{
	UDIError	Err;
	UDISizeT _far	*CountDonePtr;
	long		Buffer_Adjustment;

	_Packed struct {
		REALPTR		Buf;
		UDISizeT	Count;
		REALPTR		CountDone;
	} params;

	/* Get pointers to passed-by-reference variables in parameter
	 * passing buffer. 
	 */
	CountDonePtr = (UDISizeT _far *) (rm_address + Count);

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

	/* Copy "in" passed-by-reference variables to parameter passing
	 * buffer.
	 */
	_fmemmove(rm_address,NEARPTR_TO_FARPTR(Buf),Count);

	params.Buf       = rm_buffer_addr;
	params.Count     = Count;
	params.CountDone = PROT_TO_REAL((FARPTR)CountDonePtr);

	Err = REALCALL(UDIPutStdinAddr,params);

	CheckRealError(Err,"UDIPutStdin");

	/* Copy returned values back into protected mode variables. */
	_fmemmove(NEARPTR_TO_FARPTR(CountDone),CountDonePtr,sizeof(UDISizeT));

	return FUNC_VAL;


} /* UDIPPutStdin() */



UDIError UDIPStdinMode(
	REALPTR		UDIStdinModeAddr,
	UDIMode		*Mode			/* Out */
	)
{
	UDIError	Err;

	/* Don't need to copy anything in parameter passing area since there
	 * are no "in", passed-by-reference parameters.  
	 * Since there is only a single parameter and that is "out", and
	 * passed-by-reference, can just use the address of the parameter
	 * passing buffer for this.
	 */
	Err = REALCALL(UDIStdinModeAddr,rm_buffer_addr);

	CheckRealError(Err,"UDIStdinMode");

	_fmemmove(NEARPTR_TO_FARPTR(Mode),rm_address,sizeof(UDIMode));

	return FUNC_VAL;

} /* UDIPStdinMode() */



UDIError UDIPPutTrans(
	REALPTR		UDIPutTransAddr,
	UDIHostMemPtr	Buf,			/* In  */
	UDISizeT	Count,			/* In  */
	UDISizeT	*CountDone		/* Out */
	)
{
	UDIError	Err;
	UDISizeT _far	*CountDonePtr;

	char *		CurrentTo;
	UDISizeT	TotalDone=0;
	UDISizeT	CurrentCount;
	UDISizeT	CurrentDone=0;
	long		BufAdjust;

	_Packed struct {
		REALPTR		Buf;
		UDISizeT	Count;
		REALPTR		CountDone;
	} params;

	CurrentCount = Count;
	CurrentTo = Buf;

	do {
		CountDonePtr = (UDISizeT _far *) (rm_address + CurrentCount);

		BufAdjust = BufferSizeCheck((FARPTR)(CountDonePtr + sizeof(UDISizeT)),"UDIPPutTrans",PRINT_OFF);
		if (BufAdjust) {
			CurrentCount = (rm_end_address - rm_address - sizeof(UDISizeT));
			CountDonePtr = (UDISizeT _far *) (rm_end_address - sizeof(UDISizeT));
		} /* if */

		_fmemmove(rm_address,NEARPTR_TO_FARPTR(Buf),Count);

		params.Buf       = rm_buffer_addr;
		params.Count     = CurrentCount;
		params.CountDone = PROT_TO_REAL((FARPTR)CountDonePtr);

		Err = REALCALL(UDIPutTransAddr,params);

		CheckRealError(Err,"UDIPutTrans");

		/* Copy the contents of the "out" parameters back into their
		 * protected mode counterparts.
		 */
		_fmemmove(NEARPTR_TO_FARPTR(&CurrentDone),CountDonePtr,sizeof(UDISizeT));

		TotalDone += CurrentDone;

	} while ((TotalDone < Count) & (FUNC_VAL == UDINoError));

	*CountDone = TotalDone;
	return FUNC_VAL;

} /* UDIPPutTrans() */



UDIError UDIPGetTrans(
	REALPTR		UDIGetTransAddr,
	UDIHostMemPtr	Buf,			/* Out */
	UDISizeT	BufSize,		/* In  */
	UDISizeT	*CountDone		/* Out */
	)
{
	UDIError	Err;
	UDISizeT _far	*CountDonePtr;
	long		BufAdjust;

	_Packed struct {
		REALPTR		Buf;
		UDISizeT	BufSize;
		REALPTR		CountDone;
	} params;

	/* Get pointers to passed-by-reference parameters. */
	CountDonePtr = (UDISizeT _far *) (rm_address + BufSize);

	if ((BufAdjust = BufferSizeCheck((FARPTR)(CountDonePtr + sizeof(UDISizeT)),"UDIPGetTrans",PRINT_ON))) {
		if (BufSize <= BufAdjust)
			return UDIErrorIPCLimitation;
		BufSize -= BufAdjust;
	} /* if */

	params.Buf       = rm_buffer_addr;
	params.BufSize   = BufSize;
	params.CountDone = PROT_TO_REAL((FARPTR)CountDonePtr);

	Err = REALCALL(UDIGetTransAddr,params);

	CheckRealError(Err,"UDIGetTrans");

	/* Copy the contents of the "out" parameters back into their
	 * protected mode counterparts.
	 */
	_fmemmove(NEARPTR_TO_FARPTR(CountDone),CountDonePtr,sizeof(UDISizeT));
	if (*CountDone <= BufSize)
		_fmemmove(NEARPTR_TO_FARPTR(Buf),rm_address,*CountDone);
	else {
		_fmemmove(NEARPTR_TO_FARPTR(Buf),rm_address,BufSize);
		SIZE_ERROR(*CountDone, BufSize, "UDIPGetTrans");
	}

	return FUNC_VAL;


} /* UDIPGetTrans() */


UDIError UDIPTransMode(
	REALPTR		UDITransModeAddr,
	UDIMode		*Mode			/* Out */
	)
{
	UDIError	Err;

	/* Don't need to copy anything in parameter passing area since there
	 * are no "in", passed-by-reference parameters.  
	 * Since there is only a single parameter and that is "out", and
	 * passed-by-reference, can just use the address of the parameter
	 * passing buffer for this.
	 */

	Err = REALCALL(UDITransModeAddr,rm_buffer_addr);

	CheckRealError(Err,"UDITransMode");

	_fmemmove(NEARPTR_TO_FARPTR(Mode),rm_address,sizeof(UDIMode));

	return FUNC_VAL;

} /* UDIPTransMode() */