lbbs/src/io.c

/***************************************************************************
                            io.c  -  description
                             -------------------
    begin                : Mon Oct 18 2004
    copyright            : (C) 2004 by Leaflet
    email                : leaflet@leafok.com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include "io.h"
#include "common.h"
#include <stdio.h>
#include <stdarg.h>
#include <time.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>

int
outc (char c)
{
  int retval;

  retval = fprintf (stdout, "%c", c);

  return retval;
}

int
prints (const char *format, ...)
{
  va_list args;
  int retval;

  va_start (args, format);
  retval = vfprintf (stdout, format, args);
  va_end (args);

  return retval;
}

int
iflush ()
{
  int retval;

  retval = fflush (stdout);

  return retval;
}

int
igetch ()
{
  static char buf[256];
  unsigned char c, tmp[256];
  int out = KEY_NULL, loop = 1, in_esc = 0, in_ascii = 0, in_control = 0, i =
    0, j, result;
  static int len = 0, pos = 0;
  fd_set inputs, testfds;
  struct timeval timeout;

  if (pos >= len)
    {
      pos = 0;
      len = 0;

      FD_ZERO (&inputs);
      FD_SET (0, &inputs);

      testfds = inputs;
      timeout.tv_sec = 1;
      timeout.tv_usec = 0;

      result = select (FD_SETSIZE, &testfds, (fd_set *) NULL,
                       (fd_set *) NULL, &timeout);

      switch (result)
        {
        case 0:
          out = KEY_TIMEOUT;
          break;
        case -1:
          log_error ("select() error!\n");
          break;
        default:
          if (FD_ISSET (0, &testfds))
            {
              len = read (0, buf, 255);
            }
          break;
        }

      //For debug
      //for (j = 0; j < len; j++)
      //  log_std ("<--[%u]\n", (buf[j] + 256) % 256);
    }

  while (pos < len)
    {
      c = buf[pos++];

      if (c == '\0')
        {
          out = c;
          break;
        }

      if (c == KEY_CONTROL)
        {
          if (in_control == 0)
            {
              in_control = 1;
              i = 0;
              continue;
            }
        }

      if (in_control)
        {
          tmp[i++] = c;
          if (i >= 2)
            {
              out = (int) tmp[0] * 256 + tmp[1];
              in_control = 0;
              break;
            }
          continue;
        }

      if (c == ESC_KEY)
        {
          if (in_esc == 0)
            {
              in_esc = 1;
              in_ascii = 1;
              i = 0;
              continue;
            }
          else
            {
              out = ESC_KEY;
              in_esc = 0;
              break;
            }
        }

      in_esc = 0;

      if (in_ascii)
        {
          tmp[i++] = c;
          if (c == 'm')
            {
              in_ascii = 0;
              continue;
            }
          if (i == 2 && c >= 'A' && c <= 'D')
            {
              in_ascii = 0;
              switch (c)
                {
                case 'A':
                  out = KEY_UP;
                  break;
                case 'B':
                  out = KEY_DOWN;
                  break;
                case 'C':
                  out = KEY_RIGHT;
                  break;
                case 'D':
                  out = KEY_LEFT;
                  break;
                }
              break;
            }
          if (i == 3 && tmp[0] == 91 && tmp[2] == 126)
            {
              in_ascii = 0;
              switch (tmp[1])
                {
                case 49:
                  out = KEY_HOME;
                  break;
                case 51:
                  out = KEY_DEL;
                  break;
                case 52:
                  out = KEY_END;
                  break;
                case 53:
                  out = KEY_PGUP;
                  break;
                case 54:
                  out = KEY_PGDN;
                  break;
                }
              break;
            }
          continue;
        }

      out = ((int) c + 256) % 256;
      break;
    }

  //for debug
  //log_std ("-->[%u]\n", out);

  return out;
}

int
igetch_t (long int sec)
{
  int ch;
  time_t t_begin = time(0);
  
  do {
    ch = igetch ();
  } while ((ch == KEY_TIMEOUT) && (time(0) - t_begin < sec));

  return ch;
}

int
ikbhit ()
{
  int len;

  ioctl (0, FIONREAD, &len);

  return len;
}
1	sysadm	1.1	/***************************************************************************
2			io.c - description
3			-------------------
4			begin : Mon Oct 18 2004
5			copyright : (C) 2004 by Leaflet
6			email : leaflet@leafok.com
7			***************************************************************************/
8
9			/***************************************************************************
10			* *
11			* This program is free software; you can redistribute it and/or modify *
12			* it under the terms of the GNU General Public License as published by *
13			* the Free Software Foundation; either version 2 of the License, or *
14			* (at your option) any later version. *
15			* *
16			***************************************************************************/
17
18			#include "io.h"
19			#include "common.h"
20			#include <stdio.h>
21			#include <stdarg.h>
22	sysadm	1.9	#include <time.h>
23			#include <fcntl.h>
24			#include <unistd.h>
25	sysadm	1.5	#include <sys/ioctl.h>
26	sysadm	1.1
27			int
28	sysadm	1.6	outc (char c)
29	sysadm	1.1	{
30			int retval;
31
32	sysadm	1.6	retval = fprintf (stdout, "%c", c);
33	sysadm	1.1
34			return retval;
35			}
36
37			int
38	sysadm	1.6	prints (const char *format, ...)
39	sysadm	1.1	{
40			va_list args;
41			int retval;
42
43			va_start (args, format);
44			retval = vfprintf (stdout, format, args);
45			va_end (args);
46
47			return retval;
48			}
49
50			int
51	sysadm	1.6	iflush ()
52	sysadm	1.1	{
53			int retval;
54	sysadm	1.6
55	sysadm	1.1	retval = fflush (stdout);
56	sysadm	1.6
57	sysadm	1.1	return retval;
58			}
59
60			int
61			igetch ()
62			{
63			static char buf[256];
64	sysadm	1.3	unsigned char c, tmp[256];
65	sysadm	1.8	int out = KEY_NULL, loop = 1, in_esc = 0, in_ascii = 0, in_control = 0, i =
66	sysadm	1.9	0, j, result;
67	sysadm	1.6	static int len = 0, pos = 0;
68	sysadm	1.9	fd_set inputs, testfds;
69			struct timeval timeout;
70	sysadm	1.1
71			if (pos >= len)
72	sysadm	1.6	{
73			pos = 0;
74	sysadm	1.9	len = 0;
75	sysadm	1.2
76	sysadm	1.9	FD_ZERO (&inputs);
77			FD_SET (0, &inputs);
78
79			testfds = inputs;
80			timeout.tv_sec = 1;
81			timeout.tv_usec = 0;
82
83			result = select (FD_SETSIZE, &testfds, (fd_set *) NULL,
84			(fd_set *) NULL, &timeout);
85
86			switch (result)
87			{
88			case 0:
89			out = KEY_TIMEOUT;
90			break;
91			case -1:
92			log_error ("select() error!\n");
93			break;
94			default:
95			if (FD_ISSET (0, &testfds))
96			{
97			len = read (0, buf, 255);
98			}
99			break;
100			}
101	sysadm	1.5
102	sysadm	1.6	//For debug
103			//for (j = 0; j < len; j++)
104			// log_std ("<--[%u]\n", (buf[j] + 256) % 256);
105			}
106	sysadm	1.1
107			while (pos < len)
108			{
109			c = buf[pos++];
110
111			if (c == '\0')
112	sysadm	1.6	{
113			out = c;
114			break;
115			}
116	sysadm	1.1
117	sysadm	1.3	if (c == KEY_CONTROL)
118	sysadm	1.6	{
119			if (in_control == 0)
120			{
121			in_control = 1;
122			i = 0;
123			continue;
124			}
125			}
126
127	sysadm	1.3	if (in_control)
128	sysadm	1.6	{
129			tmp[i++] = c;
130			if (i >= 2)
131			{
132			out = (int) tmp[0] * 256 + tmp[1];
133			in_control = 0;
134			break;
135			}
136			continue;
137			}
138	sysadm	1.3
139	sysadm	1.1	if (c == ESC_KEY)
140			{
141			if (in_esc == 0)
142			{
143			in_esc = 1;
144			in_ascii = 1;
145			i = 0;
146			continue;
147			}
148			else
149			{
150			out = ESC_KEY;
151			in_esc = 0;
152			break;
153			}
154			}
155
156			in_esc = 0;
157
158			if (in_ascii)
159			{
160			tmp[i++] = c;
161			if (c == 'm')
162			{
163			in_ascii = 0;
164			continue;
165			}
166			if (i == 2 && c >= 'A' && c <= 'D')
167			{
168			in_ascii = 0;
169			switch (c)
170			{
171			case 'A':
172			out = KEY_UP;
173			break;
174			case 'B':
175			out = KEY_DOWN;
176			break;
177			case 'C':
178	sysadm	1.2	out = KEY_RIGHT;
179			break;
180			case 'D':
181	sysadm	1.1	out = KEY_LEFT;
182			break;
183	sysadm	1.2	}
184			break;
185			}
186			if (i == 3 && tmp[0] == 91 && tmp[2] == 126)
187			{
188			in_ascii = 0;
189			switch (tmp[1])
190			{
191			case 49:
192			out = KEY_HOME;
193			break;
194	sysadm	1.4	case 51:
195			out = KEY_DEL;
196			break;
197	sysadm	1.2	case 52:
198			out = KEY_END;
199			break;
200			case 53:
201			out = KEY_PGUP;
202			break;
203			case 54:
204	sysadm	1.8	out = KEY_PGDN;
205	sysadm	1.1	break;
206			}
207			break;
208			}
209			continue;
210			}
211
212	sysadm	1.6	out = ((int) c + 256) % 256;
213	sysadm	1.1	break;
214			}
215
216			//for debug
217	sysadm	1.5	//log_std ("-->[%u]\n", out);
218	sysadm	1.1
219			return out;
220			}
221	sysadm	1.5
222			int
223	sysadm	1.9	igetch_t (long int sec)
224			{
225			int ch;
226			time_t t_begin = time(0);
227
228			do {
229			ch = igetch ();
230			} while ((ch == KEY_TIMEOUT) && (time(0) - t_begin < sec));
231
232			return ch;
233			}
234
235			int
236	sysadm	1.6	ikbhit ()
237	sysadm	1.5	{
238			int len;
239	sysadm	1.6
240	sysadm	1.5	ioctl (0, FIONREAD, &len);
241	sysadm	1.6
242	sysadm	1.5	return len;
243			}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1