io.c

Linux下VB解释器

      rec->Event.KeyEvent.wVirtualKeyCode == VK_CONTROL)
    {
      return FALSE;
    }
  return TRUE;
}
#endif


char *
replace (char *string)		/* replace \n,\a, etc. */
{
  char *from, *to;
  char *p;
  int val;
  static char *hexdigits = "0123456789abcdef";

  from = to = string;
  while (*from)
    {
      if (*from == '\\')
	{
	  from++;
	  switch (*from)
	    {
	    case 'n':
	      *to = '\n';
	      break;
	    case 't':
	      *to = '\t';
	      break;
	    case 'v':
	      *to = '\v';
	      break;
	    case 'b':
	      *to = '\b';
	      break;
	    case 'r':
	      *to = '\r';
	      break;
	    case 'f':
	      *to = '\f';
	      break;
	    case 'a':
	      *to = '\a';
	      break;
	    case '\\':
	      *to = '\\';
	      break;
	    case '\?':
	      *to = '\?';
	      break;
	    case '\'':
	      *to = '\'';
	      break;
	    case '\"':
	      *to = '\"';
	      break;
	    case 'x':
	      val = 0;
	      if ((p = strchr (hexdigits, tolower (*(from + 1))))
		  && p - hexdigits < 16)
		{
		  from++;
		  val = p - hexdigits;
		  if ((p = strchr (hexdigits, tolower (*(from + 1))))
		      && p - hexdigits < 16)
		    {
		      from++;
		      val *= 16;
		      val += p - hexdigits;
		    }
		}
	      *to = (char) val;
	      break;
	    default:
	      *to = '\\';
	      to++;
	      *to = *from;
	    }
	}
      else
	*to = *from;
      from++;
      to++;
    }
  *to = '\0';
  return string;
}


void
create_myopen (int num)		/* create command 'myopen' */
{
  struct command *cmd;

  cmd = add_command (cOPEN, NULL);
  cmd->tag = num;
}


void
myopen (struct command *cmd)	/* open specified file for given name */
{
#ifdef WINDOWS
  char PrinterName[200];	/* Name of default Printer */
  char *n;			/* points into PrinterName */
  DOC_INFO_1 di;
#endif
  FILE *handle = NULL;
  int stream, i;
  char *name = NULL;
  char *mode = NULL;
  char **pmode;
  static char *valid_modes[] = { "r", "w", "a", "rb", "wb", "ab", "" };
  static int smodes[] =
      { smREAD, smWRITE, smWRITE, smREAD, smWRITE, smWRITE };
  int smode;
  struct stackentry *p;
  int has_mode, has_stream, printer;

  /* decode cmd->tag */
  has_stream = cmd->tag & OPEN_HAS_STREAM;
  has_mode = cmd->tag & OPEN_HAS_MODE;
  printer = cmd->tag & OPEN_PRINTER;

  if (has_mode)
    mode = my_strdup (pop (stSTRING)->pointer);
  else
    mode = printer ? my_strdup ("w") : my_strdup ("r");
  if (printer)
    name = my_strdup ("/usr/bin/lpr");
  else
    name = my_strdup (pop (stSTRING)->pointer);

  if (has_stream)
    {
      stream = (int) pop (stNUMBER)->value;
    }
  else
    {
      stream = 0;
      for (i = 1; i < FOPEN_MAX - 4; i++)
	{
	  if (stream_modes[i] == smCLOSED)
	    {
	      stream = i;
	      break;
	    }
	}
      if (!stream)
	{
	  sprintf (errorstring, "reached maximum number of open files");
	  errorcode = 5;
	  goto open_done;
	}
    }

  p = push ();
  p->value = 0.;
  p->type = stNUMBER;

  if (printer && print_to_file)
    {
      sprintf (errorstring,
	       "cannot open printer: already printing grafics");
      errorcode = 6;
      goto open_done;
    }

  if (badstream (stream, 1))
    {
      sprintf (errorstring, "invalid stream number %d", stream);
      errorcode = 9;
      goto open_done;
    }
  if (stream_modes[stream] != smCLOSED)
    {
      sprintf (errorstring, "stream already in use");
      errorcode = 2;
      goto open_done;
    }

  smode = 0;
  for (pmode = valid_modes; **pmode; pmode++)
    {
      if (!strcmp (*pmode, mode))
	break;
      smode++;
    }
  if (!**pmode)
    {
      sprintf (errorstring, "\'%s\' is not a valid filemode", mode);
      errorcode = 3;
      goto open_done;
    }

  if (printer)
    {
#ifdef UNIX
      lineprinter = popen (name, "w");
      if (!lineprinter)
	{
	  sprintf (errorstring, "could not open line printer");
	  errorcode = 7;
	  goto open_done;
	}
#else
      /* query win.ini for default printer */
      GetProfileString ("windows", "device", ",,,", PrinterName, 200);

      /* truncate printer name */
      n = PrinterName;
      while (*n && *n != ',')
	n++;
      *n = '\0';

      OpenPrinter (PrinterName, &lineprinter, NULL);
      di.pDocName = "yabasic text";
      di.pOutputFile = (LPTSTR) NULL;
      di.pDatatype = "RAW";
      if (!StartDocPrinter (lineprinter, 1, (LPBYTE) & di))
	{
	  sprintf (errorstring, "could not open line printer");
	  errorcode = 7;
	  goto open_done;
	}
      StartPagePrinter (lineprinter);
#endif
      lprstream = stream;
    }
  else
    {
      handle = fopen (name, mode);
      if (handle == NULL)
	{
	  sprintf (errorstring, "could not open '%s': %s", name,
		   my_strerror (errno));
	  errorcode = 4;
	  goto open_done;
	}
      streams[stream] = handle;
    }
  stream_modes[stream] = smodes[smode];
  errorcode = 0;
  p->value = stream;
open_done:
  if (name)
    my_free (name);
  if (mode)
    my_free (mode);
}


void
checkopen (void)		/* check, if open has been sucessfull */
{
  double result;

  result = pop (stNUMBER)->value;
  if (result <= 0)
    {
      error (ERROR, errorstring);
    }
}


void
myclose (void)			/* close the specified stream */
{
  int s;
#ifdef WINDOWS
  DWORD written;
#endif

  s = (int) pop (stNUMBER)->value;
  if (abs (s) == STDIO_STREAM || badstream (s, 0))
    return;
  if (stream_modes[s] == smCLOSED)
    {
      sprintf (string, "stream %d already closed", s);
      error (WARNING, string);
      return;
    }
  if (s == lprstream)
    {
#ifdef UNIX
      pclose (lineprinter);
#else
      WritePrinter (lineprinter, "\f", 2, &written);
      EndPagePrinter (lineprinter);
      EndDocPrinter (lineprinter);
      ClosePrinter (lineprinter);
      lineprinter = INVALID_HANDLE_VALUE;
#endif
      lprstream = -1;
    }
  else
    {
      fclose (streams[s]);
    }
  streams[s] = NULL;
  stream_modes[s] = smCLOSED;
}


void
myseek (struct command *cmd)	/* reposition file pointer */
{
  int s, p, m, i;
  struct stackentry *pp;
  char *mode;

  if (cmd->type == cSEEK2)
    mode = (char *) my_strdup (pop (stSTRING)->pointer);
  else
    mode = my_strdup ("begin");
  p = (int) pop (stNUMBER)->value;
  s = (int) pop (stNUMBER)->value;
  pp = push ();
  pp->value = 0.;
  pp->type = stNUMBER;
  for (i = 0; mode[i]; i++)
    mode[i] = tolower (mode[i]);
  if (!strcmp (mode, "begin"))
    {
      m = SEEK_SET;
    }
  else if (!strcmp (mode, "end"))
    {
      m = SEEK_END;
    }
  else if (!strcmp (mode, "here"))
    {
      m = SEEK_CUR;
    }
  else
    {
      sprintf (errorstring, "seek mode '%s' is none of begin,end,here",
	       mode);
      errorcode = 12;
      my_free (mode);
      return;
    }
  my_free (mode);
  if (abs (s) == STDIO_STREAM || badstream (s, 0))
    return;
  if (!(stream_modes[s] & (smREAD | smWRITE)))
    {
      sprintf (errorstring, "stream %d not open", s);
      errorcode = 11;
      return;
    }
  if (fseek (streams[s], (long) p, m))
    {
      sprintf (errorstring, "could not position stream %d to byte %d", s,
	       p);
      errorcode = 10;
      return;
    }
  pp->value = 1.0;
}


void
create_pps (int type, int input)	/* create command pushswitch or popswitch */
{
  struct command *cmd;

  cmd = add_command (type, NULL);
  cmd->args = input;
}


void
push_switch (struct command *cmd)	/* push current stream on stack and switch to new one */
{
  static int oldstream = STDIO_STREAM;
  struct stackentry *s;
  int stream;

  stream = (int) pop (stNUMBER)->value;
  if (badstream (stream, 0))
    return;
  if (!cmd->args)
    stream = -stream;

  s = push ();
  s->type = stNUMBER;
  s->value = oldstream;
  if (infolevel >= DEBUG)
    {
      sprintf (string, "pushing %d on stack, switching to %d", oldstream,
	       stream);
      error (DEBUG, string);
    }
  oldstream = stream;
  myswitch (stream);
}


void
pop_switch (void)		/* pop current stream from stack and switch to it */
{
  int stream;

  stream = (int) pop (stNUMBER)->value;
  if (infolevel >= DEBUG)
    {
      sprintf (string, "popping %d from stack, switching to it", stream);
      error (DEBUG, string);
    }
  myswitch (stream);
}


void
myswitch (int stream)		/* switch to specified stream */
{
  int stdio, input;

  stdio = (abs (stream) == STDIO_STREAM);
  input = (stream > 0);
  currstr = stream;
  if (stream < 0)
    stream = -stream;
  if (badstream (stream, 0))
    return;

  if (stdio)
    {
      cinstr = stdin;
      coutstr = stdout;
    }
  else
    {
      cinstr = coutstr = NULL;
      if (input)
	cinstr = streams[stream];
      else
	coutstr = streams[stream];
    }
}


int
checkstream (void)		/* test if currst is still valid */
{
  int stdio, input;

  stdio = (abs (currstr) == STDIO_STREAM);
  input = (currstr > 0);

  if (!stdio)
    {
      if (input && !(stream_modes[abs (currstr)] & smREAD))
	{
	  sprintf (string, "stream %d not open for reading",
		   abs (currstr));
	  error (ERROR, string);
	  return FALSE;
	}
      if (!input && !(stream_modes[abs (currstr)] & (smWRITE | smPRINT)))
	{
	  sprintf (string, "stream %d not open for writing or printing",
		   abs (currstr));
	  error (ERROR, string);
	  return FALSE;
	}
    }
  return TRUE;
}


void
testeof (struct command *cmd)	/* close the specified stream */
{
  int s, c;
  struct stackentry *result;

  s = (int) pop (stNUMBER)->value;
  if (s != STDIO_STREAM && badstream (s, 0))
    return;
  result = push ();
  result->type = stNUMBER;
  if (s && !(stream_modes[s] & smREAD))
    {
      result->value = 1.;
      return;
    }
  if (!s)
    {
      result->value = 0.;
      return;
    }
  c = getc (streams[s]);
  if (c == EOF)
    {
      result->value = 1.;
      return;
    }

  result->value = 0.;
  ungetc (c, streams[s]);
  return;
}


int
badstream (int stream, int errcode)	/* test for valid stream id */
{
  if (stream != STDIO_STREAM && (stream > FOPEN_MAX - 4 || stream <= 0))
    {
      sprintf (errcode ? errorstring : string,
	       "invalid stream: %d (can handle only streams from 1 to %d)",
	       stream, FOPEN_MAX - 4);
      if (errcode)
	errorcode = errcode;
      else
	error (ERROR, string);
      return TRUE;
    }
  return FALSE;
}


void
create_myread (char type, int tileol)	/* create command 'read' */
{
  struct command *cmd;

  cmd = add_command (cREAD, NULL);
  cmd->args = tileol;		/* true, if read should go til eol */
  cmd->tag = type;		/* can be 'd' or 's' */
}


void
myread (struct command *cmd)	/* read string or double */
{
  double d;
  static char buffer[INBUFFLEN];	/* buffer with current input */
  int numread;			/* number of bytes read */
  int tileol;			/* true, if read should go til end of line */
  struct stackentry *s;
  int currch;			/* current character */

  numread = 0;			/* no chars read'til now */
  buffer[0] = '\0';
  tileol = cmd->args;

  /* skip leading whitespace */
  if (!tileol)
    {
      do
	{
	  currch = onechar ();
	}
      while (currch == ' ' || currch == '\t');
      /* put back last char */
      if (currch != EOF && currch != '\0')
	backchar (currch);
      if (currch == '\0' || currch == EOF)
	goto done;
    }

  /* read chars */
  do
    {
      currch = onechar ();
      buffer[numread] = currch;
      numread++;
    }
  while (((tileol && currch != '\0') ||
	  (!tileol && currch != ' ' &&
	   currch != '\t' && currch != '\0')) &&
	 currch != EOF && numread < INBUFFLEN);

  /* put back last char */
  if (currch != EOF && currch != '\0')
    backchar (currch);
  /* and remove it from buff */
  if (currch != EOF)
    numread--;
  buffer[numread] = '\0';
  if (currch == '\0' || currch == EOF)
    goto done;

  /* skip trailing whitespace */
  if (!tileol)
    {
      do
	{
	  currch = onechar ();
	}
      while (currch == ' ' || currch == '\t');
      if (currch != EOF && currch != '\0')
	backchar (currch);
    }

done:
  if (cmd->tag == 's')
    {				/* read string */
      s = push ();
      s->type = stSTRING;
      s->pointer = my_strdup (buffer);
    }
  else
    {				/* read double */
      s = push ();
      s->type = stNUMBER;
      s->value = 0.0;
      if (buffer[0] && (sscanf (buffer, "%lf", &d) == 1))
	s->value = d;
    }
}


static void
readline (void)			/* read one line from current stream */
{
#ifdef UNIX
  char *nl;			/* position of newline */
  int x, y;
#else
  int read;
#endif

  if (!checkstream ())
    return;
  linebuffer[0] = '\0';
#ifdef UNIX
  if (curinized && cinstr == stdin)
    {
      getyx (stdscr, y, x);
#ifdef HAVE_GETNSTR
      getnstr (linebuffer, INBUFFLEN);
#else
      getstr (linebuffer);
#endif
      if ((nl = strchr (linebuffer, '\0')))
	{
	  *nl = '\n';
	  *(nl + 1) = '\0';
	}
      if (y >= LINES - 1)
	scrl (1);
      refresh ();
    }
#else
  if (curinized && cinstr == stdin)
    {
      FlushConsoleInputBuffer (ConsoleInput);
      ReadConsole (ConsoleInput, linebuffer, INBUFFLEN, &read, NULL);
      if (read >= 2)
	{
	  linebuffer[read - 2] = '\n';