sltermin.c

ReactOS是一些高手根据Windows XP的内核编写出的类XP。内核实现机理和API函数调用几乎相同。甚至可以兼容XP的程序。喜欢研究系统内核的人可以看一看。

{
   int offset;
   Terminfo_Type *t;

   if ((pp == NULL) || (NULL == (t = (Terminfo_Type *) *pp))) return -1;

   if (t->flags == SLTERMCAP) return tcap_getnum (cap, t);

   offset = compute_cap_offset (cap, t, Tgetnum_Map, t->num_numbers);
   if (offset < 0) return -1;
   return make_integer (t->numbers + 2 * offset);
}

static Tgetstr_Map_Type Tgetflag_Map[] =
{
   {"am", 1		UNTIC_COMMENT("auto right margin")},
   {"hs", 9 		UNTIC_COMMENT("has status line")},
   {"ms", 14		UNTIC_COMMENT("move standout mode")},
   {"xs", 3		UNTIC_COMMENT("ceol standout glitch")},
   {"xn", 4		UNTIC_COMMENT("NEWLINE ignored after 80 columns")},
   {"es", 16   		UNTIC_COMMENT("status line esc ok")},
   {"", -1		UNTIC_COMMENT(NULL)}
};

int SLtt_tigetflag (char *cap, char **pp)
{
   int offset;
   Terminfo_Type *t;

   if ((pp == NULL) || (NULL == (t = (Terminfo_Type *) *pp))) return -1;

   if (t->flags == SLTERMCAP) return tcap_getflag (cap, t);

   offset = compute_cap_offset (cap, t, Tgetflag_Map, t->boolean_section_size);

   if (offset < 0) return -1;
   return (int) *(t->boolean_flags + offset);
}



/* These are my termcap routines.  They only work with the TERMCAP environment
 * variable.  This variable must contain the termcap entry and NOT the file.
 */

static int tcap_getflag (char *cap, Terminfo_Type *t)
{
   char a, b;
   char *f = (char *) t->boolean_flags;
   char *fmax;

   if (f == NULL) return 0;
   fmax = f + t->boolean_section_size;

   a = *cap;
   b = *(cap + 1);
   while (f < fmax)
     {
	if ((a == f[0]) && (b == f[1]))
	  return 1;
	f += 2;
     }
   return 0;
}

static char *tcap_get_cap (unsigned char *cap, unsigned char *caps, unsigned int len)
{
   unsigned char c0, c1;
   unsigned char *caps_max;

   c0 = cap[0];
   c1 = cap[1];

   if (caps == NULL) return NULL;
   caps_max = caps + len;
   while (caps < caps_max)
     {
	if ((c0 == caps[0]) && (c1 == caps[1]))
	  {
	     return (char *) caps + 3;
	  }
	caps += (int) caps[2];
     }
   return NULL;
}


static int tcap_getnum (char *cap, Terminfo_Type *t)
{
   cap = tcap_get_cap ((unsigned char *) cap, t->numbers, t->num_numbers);
   if (cap == NULL) return -1;
   return atoi (cap);
}

static char *tcap_getstr (char *cap, Terminfo_Type *t)
{
   return tcap_get_cap ((unsigned char *) cap, (unsigned char *) t->string_table, t->string_table_size);
}

static int tcap_extract_field (unsigned char *t0)
{
   register unsigned char ch, *t = t0;
   while (((ch = *t) != 0) && (ch != ':')) t++;
   if (ch == ':') return (int) (t - t0);
   return -1;
}

int SLtt_Try_Termcap = 1;
static int tcap_getent (char *term, Terminfo_Type *ti)
{
   unsigned char *termcap, ch;
   unsigned char *buf, *b;
   unsigned char *t;
   int len;

   if (SLtt_Try_Termcap == 0) return -1;
#if 1
   /* XFREE86 xterm sets the TERMCAP environment variable to an invalid
    * value.  Specifically, it lacks the tc= string.
    */
   if (!strncmp (term, "xterm", 5))
     return -1;
#endif
   termcap = (unsigned char *) getenv ("TERMCAP");
   if ((termcap == NULL) || (*termcap == '/')) return -1;

   /* We have a termcap so lets use it provided it does not have a reference
    * to another terminal via tc=.  In that case, user terminfo.  The alternative
    * would be to parse the termcap file which I do not want to do right now.
    * Besides, this is a terminfo based system and if the termcap were parsed
    * terminfo would almost never get a chance to run.  In addition, the tc=
    * thing should not occur if tset is used to set the termcap entry.
    */
   t = termcap;
   while ((len = tcap_extract_field (t)) != -1)
     {
	if ((len > 3) && (t[0] == 't') && (t[1] == 'c') && (t[2] == '='))
	  return -1;
	t += (len + 1);
     }

   /* malloc some extra space just in case it is needed. */
   len = strlen ((char *) termcap) + 256;
   if (NULL == (buf = (unsigned char *) SLMALLOC ((unsigned int) len))) return -1;

   b = buf;

   /* The beginning of the termcap entry contains the names of the entry.
    * It is terminated by a colon.
    */

   ti->terminal_names = (char *) b;
   t = termcap;
   len = tcap_extract_field (t);
   if (len < 0)
     {
	SLFREE (buf);
	return -1;
     }
   strncpy ((char *) b, (char *) t, (unsigned int) len);
   b[len] = 0;
   b += len + 1;
   ti->name_section_size = len;


   /* Now, we are really at the start of the termcap entries.  Point the
    * termcap variable here since we want to refer to this a number of times.
    */
   termcap = t + (len + 1);


   /* Process strings first. */
   ti->string_table = (char *) b;
   t = termcap;
   while (-1 != (len = tcap_extract_field (t)))
     {
	unsigned char *b1;
	unsigned char *tmax;

	/* We are looking for: XX=something */
	if ((len < 4) || (t[2] != '=') || (*t == '.'))
	  {
	     t += len + 1;
	     continue;
	  }
	tmax = t + len;
	b1 = b;

	while (t < tmax)
	  {
	     ch = *t++;
	     if ((ch == '\\') && (t < tmax))
	       {
		  t = (unsigned char *) SLexpand_escaped_char ((char *) t, (char *) &ch);
	       }
	     else if ((ch == '^') && (t < tmax))
	       {
		  ch = *t++;
		  if (ch == '?') ch = 127;
		  else ch = (ch | 0x20) - ('a' - 1);
	       }
	     *b++ = ch;
	  }
	/* Null terminate it. */
	*b++ = 0;
	len = (int) (b - b1);
	b1[2] = (unsigned char) len;    /* replace the = by the length */
	/* skip colon to next field. */
	t++;
     }
   ti->string_table_size = (int) (b - (unsigned char *) ti->string_table);

   /* Now process the numbers. */

   t = termcap;
   ti->numbers = b;
   while (-1 != (len = tcap_extract_field (t)))
     {
	unsigned char *b1;
	unsigned char *tmax;

	/* We are looking for: XX#NUMBER */
	if ((len < 4) || (t[2] != '#') || (*t == '.'))
	  {
	     t += len + 1;
	     continue;
	  }
	tmax = t + len;
	b1 = b;

	while (t < tmax)
	  {
	     *b++ = *t++;
	  }
	/* Null terminate it. */
	*b++ = 0;
	len = (int) (b - b1);
	b1[2] = (unsigned char) len;    /* replace the # by the length */
	t++;
     }
   ti->num_numbers = (int) (b - ti->numbers);

   /* Now process the flags. */
   t = termcap;
   ti->boolean_flags = b;
   while (-1 != (len = tcap_extract_field (t)))
     {
	/* We are looking for: XX#NUMBER */
	if ((len != 2) || (*t == '.') || (*t <= ' '))
	  {
	     t += len + 1;
	     continue;
	  }
	b[0] = t[0];
	b[1] = t[1];
	t += 3;
	b += 2;
     }
   ti->boolean_section_size = (int) (b - ti->boolean_flags);
   ti->flags = SLTERMCAP;
   return 0;
}

#else /* USE_SETUPTERM */

/* Ching Hui fixes so that it will work on AIX and OSF/1 */
#include <curses.h>
#include <term.h>

int SLtt_Try_Termcap = 1;

char *SLtt_tigetent (char *term)
{
    int rc;

    setupterm(term, 1, &rc);
    if (rc != 1)
	return NULL;
    return (char *)cur_term;
}

#define MATCH_CHAR(c, variable) \
    do { \
	 if (*(cap + 1) == c) \
	     return variable; \
     } while (0)

char *SLtt_tigetstr (char *cap, char **pp)
{
    if ((pp == NULL) || ((cur_term = (struct term *) *pp) == NULL))
	return NULL;

    switch(*cap) {
    case '@':
	MATCH_CHAR('7', key_end);
	break;
    case 'A':
	MATCH_CHAR('A', parm_insert_line);
	break;
    case 'D':
	MATCH_CHAR('L', parm_delete_line);
	break;
    case 'R':
	MATCH_CHAR('I', parm_right_cursor);
	break;
    case 'a':
#ifdef  acs_chars
	MATCH_CHAR('c', acs_chars);
#elif defined (box_chars_1)
	MATCH_CHAR('c', box_chars_1); /* AIX hack */
#else
	MATCH_CHAR('c', NULL);
#endif
	MATCH_CHAR('e', exit_alt_charset_mode);
	MATCH_CHAR('s', enter_alt_charset_mode);
	break;
    case 'c':
	MATCH_CHAR('e', clr_eol);
	MATCH_CHAR('l', clear_screen);
	MATCH_CHAR('m', cursor_address);
	MATCH_CHAR('s', change_scroll_region);
	break;
    case 'd':
	MATCH_CHAR('c', delete_character);
	break;
    case 'e':
	MATCH_CHAR('i', exit_insert_mode);
#ifdef ena_acs
	MATCH_CHAR('A', ena_acs); /* aix hack */
#else
	MATCH_CHAR('A', NULL);
#endif
	break;
    case 'i':
	MATCH_CHAR('m', enter_insert_mode);
	break;
    case 'k':
	MATCH_CHAR('0', key_f0);
	MATCH_CHAR('1', key_f1);
	MATCH_CHAR('1', key_f1);
	MATCH_CHAR('2', key_f2);
	MATCH_CHAR('3', key_f3);
	MATCH_CHAR('4', key_f4);
	MATCH_CHAR('5', key_f5);
	MATCH_CHAR('6', key_f6);
	MATCH_CHAR('7', key_f7);
	MATCH_CHAR('8', key_f8);
	MATCH_CHAR('9', key_f9);
	MATCH_CHAR('A', key_il);
	MATCH_CHAR('C', key_clear);
	MATCH_CHAR('D', key_dc);
	MATCH_CHAR('E', key_eol);
	MATCH_CHAR('F', key_sf);
	MATCH_CHAR('H', key_ll);
	MATCH_CHAR('I', key_ic);
	MATCH_CHAR('L', key_dl);
	MATCH_CHAR('M', key_eic);
	MATCH_CHAR('N', key_npage);
	MATCH_CHAR('P', key_ppage);
	MATCH_CHAR('R', key_sr);
	MATCH_CHAR('S', key_eos);
	MATCH_CHAR('T', key_stab);
	MATCH_CHAR('a', key_catab);
	MATCH_CHAR(';', key_f10);
	MATCH_CHAR('b', key_backspace);
	MATCH_CHAR('d', key_down);
	MATCH_CHAR('e', keypad_local);
	MATCH_CHAR('h', key_home);
	MATCH_CHAR('l', key_left);
	MATCH_CHAR('r', key_right);
	MATCH_CHAR('s', keypad_xmit);
	MATCH_CHAR('t', key_ctab);
	MATCH_CHAR('u', key_up);
	break;
    case 'm':
	MATCH_CHAR('b', enter_blink_mode);
	MATCH_CHAR('d', enter_bold_mode);
	MATCH_CHAR('e', exit_attribute_mode);
	MATCH_CHAR('r', enter_reverse_mode);
	break;
    case 's':
	MATCH_CHAR('e', exit_standout_mode);
	MATCH_CHAR('o', enter_standout_mode);
	MATCH_CHAR('r', scroll_reverse);
	break;
    case 't':
	MATCH_CHAR('e', exit_ca_mode);
	MATCH_CHAR('i', enter_ca_mode);
	break;
    case 'u':
	MATCH_CHAR('p', cursor_up);
	MATCH_CHAR('s', enter_underline_mode);
	break;
    case 'v':
	MATCH_CHAR('b', flash_screen);
	MATCH_CHAR('i', cursor_invisible);
	MATCH_CHAR('s', cursor_visible);
	break;
    case 'F':
	MATCH_CHAR('1', key_f11);
	MATCH_CHAR('2', key_f12);
	MATCH_CHAR('3', key_f13);
	MATCH_CHAR('4', key_f14);
	MATCH_CHAR('5', key_f15);
	MATCH_CHAR('6', key_f16);
	MATCH_CHAR('7', key_f17);
	MATCH_CHAR('8', key_f18);
	MATCH_CHAR('9', key_f19);
	MATCH_CHAR('A', key_f20);
	break;
#ifdef orig_pair
    case 'o':
	MATCH_CHAR('p', orig_pair);
	break;
#endif
    }
    return NULL;
}

int SLtt_tigetnum (char *cap, char **pp)
{
    if ((pp == NULL) || ((cur_term = (struct term *) *pp) == NULL))
	return (int) NULL;
    switch(*cap) {
    case 'c':
	MATCH_CHAR('o', columns);
	break;
    case 'l':
	MATCH_CHAR('i', lines);
	break;
    }
    return -1;
}

int SLtt_tigetflag (char *cap, char **pp)
{
    if ((pp == NULL) || ((cur_term = (struct term *) *pp) == NULL))
	return (int) NULL;
    switch(*cap) {
    case 'a':
	MATCH_CHAR('m', auto_right_margin);
	break;
    case 'm':
	MATCH_CHAR('s', move_standout_mode);
	break;
    case 'x':
	MATCH_CHAR('s', ceol_standout_glitch);
	break;
    case 's':
	MATCH_CHAR('g', magic_cookie_glitch);
	break;
    }
    return -1;
}

#endif /* !USE_SETUPTERM */