io.c

Linux下VB解释器

	  linebuffer[read - 1] = '\0';
	}
    }
#endif
  else
    {
      fgets (linebuffer, INBUFFLEN, cinstr);
    }
  currchar = linebuffer;
  prompted = FALSE;
}


static int
onechar ()			/* read one char from cinstr */
{
  int ch;

  if (!checkstream ())
    return '\0';
  if (cinstr == stdin)
    {
      if (!currchar || !*currchar)
	{
	  readline ();
	}
      do
	{
	  ch = *currchar;
	  currchar++;
	}
      while (!
	     (!iscntrl (ch) || strchr (" \t\n", ch) || read_controls
	      || ch == '\0'));
    }
  else
    {
      do
	{
	  ch = fgetc (cinstr);
	}
      while (!
	     (!iscntrl (ch) || strchr (" \t\n", ch) || read_controls
	      || ch == '\0' || ch == EOF));
    }

  if (ch == '\n' || ch == EOF)
    return '\0';
  else
    return ch;
}


static void
backchar (int ch)		/* put char back into stream */
{
  if (!checkstream ())
    return;
  if (cinstr == stdin)
    {
      if (currchar > linebuffer)
	currchar--;
    }
  else
    {
      ungetc (ch, cinstr);
    }
}


void
chkprompt ()			/* print an intermediate prompt if necessary */
{
  if (cinstr == stdin && (!currchar || !*currchar) && !prompted)
    onestring ("?");
}


void
create_onestring (char *str)	/* create command 'onestring' */
{
  struct command *cmd;

  cmd = add_command (cONESTRING, NULL);
  cmd->pointer = my_strdup (str);
}


void
onestring (char *s)		/* write string to file */
{
#ifdef WINDOWS
  DWORD len, written;
#endif

  if (!checkstream ())
    return;
  if (curinized && abs (currstr) == STDIO_STREAM)
    {
#ifdef UNIX
      addstr (s);
      refresh ();
#else
      len = strlen (s);
      WriteConsole (ConsoleOutput, s, len, &written, NULL);
#endif
    }
  else if (abs (currstr) == lprstream)
    {
#ifdef UNIX
      fprintf (lineprinter, "%s", s);
      fflush (lineprinter);
#else
      len = strlen (s);
      WritePrinter (lineprinter, s, len, &written);
#endif
    }
  else
    {
      fprintf (coutstr, "%s", s);
      fflush (coutstr);
    }
  prompted = TRUE;
}


void
create_colour (int flag)	/* create command 'colour' */
{
  struct command *c;

  c = add_command (cCOLOUR, NULL);
  c->args = flag;
}


void
colour (struct command *cmd)	/* switch on colour */
{
  char *fore = NULL, *back = NULL, *p;
  int fc, bc;

  if (cmd->args && !curinized)
    {
      error (ERROR, "need to call 'clear screen' first");
      return;
    }
  if (cmd->args == 0)
    {
      if (!curinized)
	return;
#ifdef UNIX
      if (has_colors ())
	attrset (A_NORMAL | COLOR_PAIR (stdfc * 8 + stdbc));
      else
	attrset (A_NORMAL);
      return;
#else
      SetConsoleTextAttribute (ConsoleOutput, (WORD) (stdfc | stdbc));
      return;
#endif
    }
  else if (cmd->args == 1)
    {
#ifdef UNIX
      if (has_colors ())
	attrset (A_NORMAL | COLOR_PAIR (stdbc * 8 + stdfc));
      else
	{
	  attrset (A_REVERSE);
	  return;
	}
#else
      SetConsoleTextAttribute (ConsoleOutput,
			       (WORD) (yc2oc (oc2yc (stdfc), 0) |
				       yc2oc (oc2yc (stdbc), 1)));
      return;
#endif
    }
  else
    {				/* decode colours */
#ifdef UNIX
      if (!has_colors ())
	{
	  pop (stSTRING);
	  if (cmd->args == 3)
	    pop (stSTRING);
	  attrset (A_REVERSE);
	  return;
	}
#endif
      if (cmd->args == 2)
	{
	  back = NULL;
	  fore = pop (stSTRING)->pointer;
	  for (p = fore; *p; p++)
	    *p = tolower (*p);
	}
      else
	{
	  back = pop (stSTRING)->pointer;
	  for (p = back; *p; p++)
	    *p = tolower (*p);
	  fore = pop (stSTRING)->pointer;
	  for (p = fore; *p; p++)
	    *p = tolower (*p);
	}
      fc = name2yc (fore);
      if (fc < 0)
	{
	  sprintf (string, "unknown foreground colour: '%s'", fore);
	  error (ERROR, string);
	}
      bc = stdbc;
      if (back)
	{
	  bc = name2yc (back);
	  if (fc < 0)
	    {
	      sprintf (string, "unknown background colour: '%s'", back);
	      error (ERROR, string);
	    }
	}
#ifdef UNIX
      attrset (COLOR_PAIR (fc * 8 + bc));
#else
      SetConsoleTextAttribute (ConsoleOutput,
			       (WORD) (yc2oc (fc, TRUE) |
				       yc2oc (bc, FALSE)));
#endif
    }
}


static void
initcol (void)			/* initialize curses colors */
{
  static int first = TRUE;
#ifdef UNIX
  int i, j, col;
  short f, b;
#else
  CONSOLE_SCREEN_BUFFER_INFO csbi;
#endif

  if (!first)
    return;
  first = FALSE;
#ifdef UNIX
  if (!has_colors ())
    return;
  start_color ();

  for (i = 0; i < 8; i++)
    {
      for (j = 0; j < 8; j++)
	{
	  if (!i && !j)
	    continue;
	  init_pair (i * 8 + j, yc2oc (i, TRUE), yc2oc (j, FALSE));
	}
    }
  init_color (COLOR_YELLOW, 1000, 1000, 0);

  col = inch () & A_COLOR;
  pair_content (col, &f, &b);
  stdfc = oc2yc (f);
  stdbc = oc2yc (b);
  bkgdset (COLOR_PAIR (stdfc * 8 + stdbc));
#else
  GetConsoleScreenBufferInfo (ConsoleOutput, &csbi);
  stdfc =
      csbi.
      wAttributes & (FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED);
  stdbc =
      csbi.
      wAttributes & (BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED);
  
#endif
}


int
name2yc (char *name)		/* convert a color name to an integer */
{
  char *c;

  for (c = name; *c; c++)
    *c = tolower (*c);
  if (!strcmp (name, "black") || !strcmp (name, "bla"))
    return YC_BLACK;
  if (!strcmp (name, "white") || !strcmp (name, "whi"))
    return YC_WHITE;
  if (!strcmp (name, "red") || !strcmp (name, "red"))
    return YC_RED;
  if (!strcmp (name, "blue") || !strcmp (name, "blu"))
    return YC_BLUE;
  if (!strcmp (name, "green") || !strcmp (name, "gre"))
    return YC_GREEN;
  if (!strcmp (name, "yellow") || !strcmp (name, "yel"))
    return YC_YELLOW;
  if (!strcmp (name, "cyan") || !strcmp (name, "cya"))
    return YC_CYAN;
  if (!strcmp (name, "magenta") || !strcmp (name, "mag"))
    return YC_MAGENTA;
  return -1;
}


int
yc2oc (int yc, int fore)	/* convert a yabasic color to operating system color */
{
#ifdef UNIX
  fore = 0;			/* stop gcc from complaining */
  if (yc == YC_BLACK)
    return COLOR_BLACK;
  if (yc == YC_WHITE)
    return COLOR_WHITE;
  if (yc == YC_RED)
    return COLOR_RED;
  if (yc == YC_BLUE)
    return COLOR_BLUE;
  if (yc == YC_GREEN)
    return COLOR_GREEN;
  if (yc == YC_YELLOW)
    return COLOR_YELLOW;
  if (yc == YC_CYAN)
    return COLOR_CYAN;
  if (yc == YC_MAGENTA)
    return COLOR_MAGENTA;
#else
  if (fore)
    {
      if (yc == YC_BLACK)
	return 0;
      if (yc == YC_WHITE)
	return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
      if (yc == YC_RED)
	return FOREGROUND_RED;
      if (yc == YC_BLUE)
	return FOREGROUND_BLUE;
      if (yc == YC_GREEN)
	return FOREGROUND_GREEN;
      if (yc == YC_YELLOW)
	return FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY;
      if (yc == YC_CYAN)
	return FOREGROUND_GREEN | FOREGROUND_BLUE;
      if (yc == YC_MAGENTA)
	return FOREGROUND_BLUE | FOREGROUND_RED;
    }
  else
    {
      if (yc == YC_BLACK)
	return 0;
      if (yc == YC_WHITE)
	return BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE;
      if (yc == YC_RED)
	return BACKGROUND_RED;
      if (yc == YC_BLUE)
	return BACKGROUND_BLUE;
      if (yc == YC_GREEN)
	return BACKGROUND_GREEN;
      if (yc == YC_YELLOW)
	return BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_INTENSITY;
      if (yc == YC_CYAN)
	return BACKGROUND_GREEN | BACKGROUND_BLUE;
      if (yc == YC_MAGENTA)
	return BACKGROUND_BLUE | BACKGROUND_RED;
    }
#endif
  return -1;
}


int
oc2yc (int oc)			/* convert an operating system color to yabasic color */
{
#ifdef UNIX
  if (oc == COLOR_BLACK)
    return YC_BLACK;
  if (oc == COLOR_WHITE)
    return YC_WHITE;
  if (oc == COLOR_RED)
    return YC_RED;
  if (oc == COLOR_BLUE)
    return YC_BLUE;
  if (oc == COLOR_GREEN)
    return YC_GREEN;
  if (oc == COLOR_YELLOW)
    return YC_YELLOW;
  if (oc == COLOR_CYAN)
    return YC_CYAN;
  if (oc == COLOR_MAGENTA)
    return YC_MAGENTA;
#else
  if (oc == 0)
    return YC_BLACK;
  if (oc == (FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN) ||
      oc == (BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_GREEN))
    return YC_WHITE;
  if (oc == (FOREGROUND_RED) || oc == (BACKGROUND_RED))
    return YC_RED;
  if (oc == (FOREGROUND_BLUE) || oc == (BACKGROUND_BLUE))
    return YC_BLUE;
  if (oc == (FOREGROUND_GREEN) || oc == (BACKGROUND_GREEN))
    return YC_GREEN;
  if (oc == (FOREGROUND_RED | FOREGROUND_GREEN) ||
      oc == (BACKGROUND_RED | BACKGROUND_GREEN) ||
      oc == (FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY) ||
      oc == (BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_INTENSITY))
    return YC_YELLOW;
  if (oc == (FOREGROUND_BLUE | FOREGROUND_GREEN) ||
      oc == (BACKGROUND_BLUE | BACKGROUND_GREEN))
    return YC_CYAN;
  if (oc == (FOREGROUND_RED | FOREGROUND_BLUE) ||
      oc == (BACKGROUND_RED | BACKGROUND_BLUE))
    return YC_MAGENTA;
#endif
  return -1;
}


void
putchars (void)			/* put rect onto screen */
{
  char *ch, text, fore[4], back[4];
  int n, sx, sy, x, y, f, b;
  int tox, toy;
  int oldx, oldy;
#ifdef WINDOWS
  CONSOLE_SCREEN_BUFFER_INFO csbi;
  COORD cp;
  WORD attributes;
  char buff[2];
  int written;
#endif

  toy = (int) (pop (stNUMBER)->value);
  tox = (int) (pop (stNUMBER)->value);
  ch = pop (stSTRING)->pointer;
#ifdef UNIX
  getyx (stdscr, oldy, oldx);
#else
  GetConsoleScreenBufferInfo (ConsoleOutput, &csbi);
  attributes = csbi.wAttributes;
  oldx = csbi.dwCursorPosition.X;
  oldy = csbi.dwCursorPosition.Y;
#endif
  if (sscanf (ch, "%d,%d:%n", &sx, &sy, &n) != 2)
    {
      error (ERROR, "illegal screen string");
      return;
    }
  ch += n;
  for (x = tox; x < tox + sx; x++)
    {
      if (x < 0 || x >= COLS)
	continue;
      for (y = toy; y < toy + sy; y++)
	{
	  if (x < 0 || x >= COLS || y < 0 || y >= LINES)
	    {
	      for (n = 0; n < 10; n++)
		if (*ch)
		  ch++;
	      continue;
	    }
	  if (!*ch)
	    {
	      text = ' ';
	      f = YC_BLACK;
	      b = YC_BLACK;
	    }
	  else
	    {
	      text = *ch;
	      strncpy (fore, ch + 2, 3);
	      fore[3] = '\0';
	      strncpy (back, ch + 6, 3);
	      back[3] = '\0';
	      for (n = 0; n < 10; n++)
		if (*ch)
		  ch++;
	      f = name2yc (fore);
	      if (f < 0)
		f = YC_WHITE;
	      b = name2yc (back);
	      if (b < 0)
		b = YC_WHITE;
	    }
#ifdef UNIX
	  if (has_colors ())
	    attrset (COLOR_PAIR (f * 8 + b));
	  mvaddch (y, x, text);
#else
	  cp.X = x;
	  cp.Y = y;
	  SetConsoleCursorPosition (ConsoleOutput, cp);
	  SetConsoleTextAttribute (ConsoleOutput,
				   (WORD) (yc2oc (f, TRUE) |
					   yc2oc (b, FALSE)));
	  buff[0] = text;
	  buff[1] = '\0';
	  WriteConsole (ConsoleOutput, buff, 1, &written, NULL);
#endif
	}
    }
#ifdef UNIX
  if (has_colors ())
    attrset (A_NORMAL | COLOR_PAIR (stdfc * 8 + stdbc));
  else
    attrset (A_NORMAL);
  move (y, x);
  refresh ();
#else
  cp.X = oldx;
  cp.Y = oldy;
  SetConsoleCursorPosition (ConsoleOutput, cp);
  SetConsoleTextAttribute (ConsoleOutput, attributes);
#endif

  return;
}


char *
getchars (int xf, int yf, int xt, int yt)	/* get rect from screen */
{
  int x, y;
#ifdef UNIX
  int c, ct, cc;
#endif
  int cf, cb;
  int oldx, oldy;
  char *res;
  char cols[20];
#ifdef WINDOWS
  CONSOLE_SCREEN_BUFFER_INFO csbi;
  COORD cp;
  char charbuff[2];
  WORD attrbuff[2];
  int read;
#endif

  if (xf > xt)
    {
      x = xf;
      xf = xt;
      xt = x;
    }
  if (yf > yt)
    {
      y = yf;
      yf = yt;
      yt = y;
    }

  res = my_malloc (12 + (xt - xf + 1) * (yt - yf + 1) * 12);
  sprintf (res, "%d,%d:", xt - xf + 1, yt - yf + 1);
#ifdef UNIX
  getyx (stdscr, oldy, oldx);
#else
  GetConsoleScreenBufferInfo (ConsoleOutput, &csbi);
  oldx = csbi.dwCursorPosition.X;
  oldy = csbi.dwCursorPosition.Y;
#endif

  for (x = xf; x <= xt; x++)
    {
      for (y = yf; y <= yt; y++)
	{
	  if (y < 0 || y >= LINES || x < 0 || x >= COLS)
	    {
	      strcat (res, " blbl");
	    }
	  else
	    {
#ifdef UNIX
	      c = mvinch (y, x);
	      ct = c & A_CHARTEXT;
	      if (!isprint (ct))
		ct = ' ';
	      cc = PAIR_NUMBER (c & A_COLOR);
	      cb = cc & 7;
	      cf = (cc - cb) / 8;
	      if (has_colors ())
		{
		  sprintf (cols, "%c:%s:%s,", ct, yc2short (cf),
			   yc2short (cb));
		}
	      else
		{
		  sprintf (cols, "%c:???:???,", ct);
		}
#else
	      cp.X = x;
	      cp.Y = y;
	      ReadConsoleOutputCharacter (ConsoleOutput, charbuff, 1, cp,
					  &read);
	      charbuff[1] = '\0';
	      ReadConsoleOutputAttribute (ConsoleOutput, attrbuff, 1, cp,
					  &read);
	      cf = oc2yc (attrbuff[0] &
			  (FOREGROUND_RED | FOREGROUND_GREEN |
			   FOREGROUND_BLUE));
	      cb = oc2yc (attrbuff[0] &
			  (BACKGROUND_RED | BACKGROUND_GREEN |
			   BACKGROUND_BLUE));
	      sprintf (cols, "%c:%s:%s,", charbuff[0], yc2short (cf),
		       yc2short (cb));
#endif
	      strcat (res, cols);
	    }
	}
    }
#ifdef UNIX
  move (oldy, oldx);
#endif
  res[strlen (res) - 1] = '\0';
  return res;
}


char *
yc2short (int col)		/* convert yabasic colours to short colour name */
{
  static char r1[4], r2[4];
  static char *pr = r1;

  if (pr == r1)
    pr = r2;
  else
    pr = r1;

  strcpy (pr, "***");
  if (col == YC_BLACK)
    strcpy (pr, "Bla");
  if (col == YC_WHITE)
    strcpy (pr, "Whi");
  if (col == YC_RED)
    strcpy (pr, "Red");
  if (col == YC_BLUE)
    strcpy (pr, "Blu");
  if (col == YC_GREEN)
    strcpy (pr, "Gre");
  if (col == YC_YELLOW)
    strcpy (pr, "Yel");
  if (col == YC_CYAN)
    strcpy (pr, "Cya");
  if (col == YC_MAGENTA)
    strcpy (pr, "Mag");

  return pr;
}