io.c

YBasic编程语言的移植和开发 YBasic编程语言的移植和开发 YBasic编程语言的移植和开发

#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';
      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,FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE);
    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,BACKGROUND_RED|BACKGROUND_GREEN|BACKGROUND_BLUE);
    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;
  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);
  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,(WORD)(stdfc|stdbc));
#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;
}