/***********************************************************************

*                                                                      *

*               This software is part of the ast package               *

*          Copyright (c) 1985-2011 AT&T Intellectual Property          *

*                      and is licensed under the                       *

*                 Eclipse Public License, Version 1.0                  *

*                    by AT&T Intellectual Property                     *

*                                                                      *

*                A copy of the License is available at                 *

*          http://www.eclipse.org/org/documents/epl-v10.html           *

*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *

*                                                                      *

*              Information and Software Systems Research               *

*                            AT&T Research                             *

*                           Florham Park NJ                            *

*                                                                      *

*                 Glenn Fowler <gsf@research.att.com>                  *

*                  David Korn <dgk@research.att.com>                   *

*                   Phong Vo <kpv@research.att.com>                    *

*                                                                      *

***********************************************************************/

#include	"sfhdr.h"

/*	Function to handle io exceptions.

**	Written by Kiem-Phong Vo

*/

#if __STD_C

int _sfexcept(Sfio_t* f, int type, ssize_t io, Sfdisc_t* disc)

#else

int _sfexcept(f,type,io,disc)

Sfio_t*		f;	/* stream where the exception happened */

int		type;	/* io type that was performed */

ssize_t		io;	/* the io return value that indicated exception */

Sfdisc_t*	disc;	/* discipline in use */

#endif

{

	reg int		ev, local, lock;

	reg ssize_t	size;

	reg uchar*	data;

	SFMTXDECL(f); /* declare a local stream variable for multithreading */

	SFMTXENTER(f,-1);

	GETLOCAL(f,local);

	lock = f->mode&SF_LOCK;

	if(local && io <= 0)

		f->flags |= io < 0 ? SF_ERROR : SF_EOF;

	if(disc && disc->exceptf)

	{	/* let the stream be generally accessible for this duration */

		if(local && lock)

			SFOPEN(f,0);

		/* so that exception handler knows what we are asking for */

		_Sfi = f->val = io;

		ev = (*(disc->exceptf))(f,type,&io,disc);

		/* relock if necessary */

		if(local && lock)

			SFLOCK(f,0);

		if(io > 0 && !(f->flags&SF_STRING) )

			SFMTXRETURN(f, ev);

		if(ev < 0)

			SFMTXRETURN(f, SF_EDONE);

		if(ev > 0)

			SFMTXRETURN(f, SF_EDISC);

	}

	if(f->flags&SF_STRING)

	{	if(type == SF_READ)

			goto chk_stack;

		else if(type != SF_WRITE && type != SF_SEEK)

			SFMTXRETURN(f, SF_EDONE);

		if(local && io >= 0)

		{	if(f->size >= 0 && !(f->flags&SF_MALLOC))

				goto chk_stack;

			/* extend buffer */

			if((size = f->size) < 0)

				size = 0;

			if((io -= size) <= 0)

				io = SF_GRAIN;

			size = ((size+io+SF_GRAIN-1)/SF_GRAIN)*SF_GRAIN;

			if(f->size > 0)

				data = (uchar*)realloc((char*)f->data,size);

			else	data = (uchar*)malloc(size);

			if(!data)

				goto chk_stack;

			f->endb = data + size;

			f->next = data + (f->next - f->data);

			f->endr = f->endw = f->data = data;

			f->size = size;

		}

		SFMTXRETURN(f, SF_EDISC);

	}

	if(errno == EINTR)

	{	if(_Sfexiting || (f->bits&SF_ENDING) ||	/* stop being a hero	*/

		   (f->flags&SF_IOINTR) ) /* application requests to return	*/

			SFMTXRETURN(f, SF_EDONE);

		/* a normal interrupt, we can continue */

		errno = 0;

		f->flags &= ~(SF_EOF|SF_ERROR);

		SFMTXRETURN(f, SF_ECONT);

	}

chk_stack:

	if(local && f->push &&

	   ((type == SF_READ  && f->next >= f->endb) ||

	    (type == SF_WRITE && f->next <= f->data)))

	{	/* pop the stack */

		reg Sfio_t	*pf;

		if(lock)

			SFOPEN(f,0);

		/* pop and close */

		pf = (*_Sfstack)(f,NIL(Sfio_t*));

		if((ev = sfclose(pf)) < 0) /* can't close, restack */

			(*_Sfstack)(f,pf);

		if(lock)

			SFLOCK(f,0);

		ev = ev < 0 ? SF_EDONE : SF_ESTACK;

	}

	else	ev = SF_EDONE;

	SFMTXRETURN(f, ev);

}