fish-shell/input_common.cpp

/** \file input_common.c
	
Implementation file for the low level input library

*/
#include "config.h"


#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <wchar.h>
#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif

#include "fallback.h"
#include "util.h"

#include "common.h"
#include "wutil.h"
#include "input_common.h"
#include "env_universal.h"
#include "iothread.h"

/**
   Time in milliseconds to wait for another byte to be available for
   reading after \\x1b is read before assuming that escape key was
   pressed, and not an escape sequence.
*/
#define WAIT_ON_ESCAPE 10

/**
   Characters that have been read and returned by the sequence matching code
*/
static wint_t lookahead_arr[1024];

/**
   Number of entries in lookahead_arr
*/
static int lookahead_count = 0;

/** Callback function for handling interrupts on reading */
static int (*interrupt_handler)();

/** Callback function to be invoked before reading each byte */
static void (*poll_handler)();


void input_common_init( int (*ih)() )
{
	interrupt_handler = ih;
}

void input_common_set_poll_callback(void (*handler)(void))
{
    poll_handler = handler;
}

void input_common_destroy()
{
	
}

/**
   Internal function used by input_common_readch to read one byte from fd 1. This function should only be called by
   input_common_readch().
*/
static wint_t readb()
{
    /* do_loop must be set on every path through the loop; leaving it uninitialized allows the static analyzer to assist in catching mistakes. */
	unsigned char arr[1];
	bool do_loop;
	
	do
	{
        /* Invoke any poll handler */
        if (poll_handler)
            poll_handler();
    
		fd_set fdset;	
		int fd_max=0;
		int ioport = iothread_port();
		int res;
		
		FD_ZERO( &fdset );
		FD_SET( 0, &fdset );
		if( env_universal_server.fd > 0 )
		{
			FD_SET( env_universal_server.fd, &fdset );
			if (fd_max < env_universal_server.fd) fd_max = env_universal_server.fd;
		}
		if (ioport > 0) {
			FD_SET( ioport, &fdset );
			if (fd_max < ioport) fd_max = ioport;
		}
				
		res = select( fd_max + 1, &fdset, 0, 0, 0 );
		if( res==-1 )
		{
			switch( errno )
			{
				case EINTR:
				case EAGAIN:
				{
					if( interrupt_handler )
					{
						int res = interrupt_handler();
						if( res )
						{
							return res;
						}
						if( lookahead_count )
						{
							return lookahead_arr[--lookahead_count];
						}
						
					}
					
					
					do_loop = true;
					break;
				}
				default:
				{
					/*
					  The terminal has been closed. Save and exit.
					*/
					return R_EOF;
				}
			}	
		}
		else
		{
            /* Assume we loop unless we see a character in stdin */
            do_loop = true;
            
            if( env_universal_server.fd > 0 && FD_ISSET( env_universal_server.fd, &fdset ) )
            {
                debug( 3, L"Wake up on universal variable event" );					
                env_universal_read_all();
                if( lookahead_count )
                {
                    return lookahead_arr[--lookahead_count];
                }
            }				
			
			if ( ioport > 0 && FD_ISSET(ioport, &fdset))
			{
                iothread_service_completion();
                if( lookahead_count )
                {
                    return lookahead_arr[--lookahead_count];
                }
			}
			
			if( FD_ISSET( STDIN_FILENO, &fdset ) )
			{
				if( read_blocked( 0, arr, 1 ) != 1 )
				{
					/* The teminal has been closed. Save and exit. */
					return R_EOF;
				}
                
                /* We read from stdin, so don't loop */
				do_loop = false;
			}				
		}
	}
	while( do_loop );
	
	return arr[0];
}

wchar_t input_common_readch( int timed )
{
	if( lookahead_count == 0 )
	{
		if( timed )
		{
			int count;
			fd_set fds;
			struct timeval tm=
				{
					0,
					1000 * WAIT_ON_ESCAPE
				}
			;
			
			FD_ZERO( &fds );
			FD_SET( 0, &fds );
			count = select(1, &fds, 0, 0, &tm);
			
			switch( count )
			{
				case 0:
					return WEOF;
					
				case -1:
					return WEOF;
					break;
				default:
					break;

			}
		}
		
		wchar_t res;
		static mbstate_t state;

		while(1)
		{
			wint_t b = readb();
			char bb;
			
			size_t sz;
			
			if( (b >= R_NULL) && (b < R_NULL + 1000) )
				return b;

			bb=b;
			
			sz = mbrtowc( &res, &bb, 1, &state );
			
			switch( sz )
			{
				case (size_t)(-1):
					memset (&state, '\0', sizeof (state));
					debug( 2, L"Illegal input" );					
					return R_NULL;					
				case (size_t)(-2):
					break;
				case 0:
					return 0;
				default:
					
					return res;
			}
		}
	}
	else 
	{
		if( !timed )
		{
			while( (lookahead_count >= 0) && (lookahead_arr[lookahead_count-1] == WEOF) )
				lookahead_count--;
			if( lookahead_count == 0 )
				return input_common_readch(0);
		}
		
		return lookahead_arr[--lookahead_count];
	}
}


void input_common_unreadch( wint_t ch )
{
	lookahead_arr[lookahead_count++] = ch;
}