开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > TCP/IP协议栈 > 查看源码
display.c
资源名称：export.zip　[点击查看]
上传用户：hepax88
上传日期：2007-01-03
资源大小：1101k
文件大小：20k
源码类别：

TCP/IP协议栈

开发平台：

Visual C++

display.c：源码内容
  1. /* ANSI display emulation
  2.  *
  3.  * This file emulates the IBM ANSI terminal display. It maintains a
  4.  * display buffer and descriptor for each virtual display, of which there
  5.  * can be many. All writes occur first into this display buffer, and then
  6.  * any particular display buffer can be copied onto the real screen.
  7.  * This allows many background tasks to run without blocking even though
  8.  * only one task's display is actually being shown.
  9.  *
  10.  * This display driver is substantially faster than even the NANSI.SYS
  11.  * loadable screen driver, particularly when large blocks are written.
  12.  *
  13.  * Extensions to handle displaying multiple small virtual windows should
  14.  * be pretty straightforward.
  15.  *
  16.  * Copyright 1992 Phil Karn, KA9Q
  17.  * 
  18.  */
  19. #include <conio.h>
  20. #include <string.h>
  21. #include <sys/stat.h>
  22. #include "global.h"
  23. #include "display.h"
  24. #include "proc.h"
  26. #define DCOL 67
  27. #define DSIZ (81-DCOL)
  29. uint8 fgattr[] = { 0, 4, 2, 14, 1, 5, 3, 7 }; /* Foreground attribs */
  30. uint8 bgattr[] = { 0, 4, 2, 6, 1, 5, 3, 7 }; /* Background attribs */
  32. static void dclrscr(struct display *dp);
  33. static void desc(struct display *dp,uint8 c);
  34. static void darg(struct display *dp,uint8 c);
  35. static void dchar(struct display *dp,uint8 c);
  36. static void dclreol(struct display *dp,int row,int col);
  37. static void dattrib(struct display *dp,int val);
  38. static uint8 *bufloc(struct display *dp,int row,int col);
  39. static void dinsline(struct display *dp);
  40. static void ddelline(struct display *dp);
  41. static void ddelchar(struct display *dp);
  42. static void dinsert(struct display *dp);
  43. static void dclreod(struct display *dp,int row,int col);
  45. extern struct proc *Display;
  47. /* Create a new virtual display.
  48.  * The "noscrol" flag, if set, causes lines to "wrap around" from the bottom
  49.  * to the top of the screen instead of scrolling the entire screen upwards
  50.  * with each new line. This can be handy for packet trace screens.
  51.  */
  52. struct display *
  53. newdisplay(rows,cols,noscrol,sflimit)
  54. int rows,cols; /* Size of new screen. 0,0 defaults to whole screen */
  55. int noscrol; /* 1: old IBM-style wrapping instead of scrolling */
  56. int sflimit; /* Scrollback file size, lines */
  57. {
  58. struct display *dp;
  59. struct text_info text_info;
  60. int i;
  62. gettextinfo(&text_info);
  63. if(rows == 0)
  64. rows = text_info.screenheight;
  65. if(cols == 0)
  66. cols = text_info.screenwidth;
  68. dp = (struct display *)calloc(1,sizeof(struct display) +
  69.  2*rows*cols + rows*sizeof(struct dirty) + cols);
  70. dp->cookie = D_COOKIE;
  71. dp->buf = (uint8 *)(dp + 1);
  72. dp->dirty = (struct dirty *)(dp->buf + 2*rows*cols);
  73. dp->tabstops = (uint8 *)(dp->dirty + rows);
  74. dp->rows = rows;
  75. dp->cols = cols;
  77. /* Set default tabs every 8 columns */
  78. for(i=0;i<cols;i+= 8)
  79. dp->tabstops[i] = 1;
  80. /* Default scrolling region is all but last line of display,
  81.  * which is reserved for a status display
  82.  */
  83. dp->slast = rows - 2;
  85. dp->attrib = 0x7; /* White on black, no blink or intensity */
  86. dclrscr(dp); /* Start with a clean slate */
  87. dclreol(dp,rows-1,0); /* Clear status line too */
  88. dp->flags.dirty_cursor = 1;
  89. dp->flags.no_scroll = noscrol;
  90. if(sflimit != 0 && (dp->sfile = tmpfile()) == NULL)
  91. sflimit = 0; /* Out of handles? */
  93. dp->sflimit = sflimit;
  94. return dp;
  95. }
  97. /* Close a display - simply get rid of the memory */
  98. void
  99. closedisplay(dp)
  100. struct display *dp;
  101. {
  102. if(dp == NULL || dp->cookie != D_COOKIE)
  103. return;
  104. if(dp->sfile != NULL)
  105. fclose(dp->sfile);
  106. free(dp);
  107. }
  109. /* Write buffer to status line. Works independently of the ANSI
  110.  * machinery so as to not upset a possible escape sequence in
  111.  * progress. Maximum of one line allowed, no control sequences
  112.  */
  113. void
  114. statwrite(dp,col,buf,cnt,attrib)
  115. struct display *dp; /* Virtual screen pointer */
  116. int col; /* Starting column of write */
  117. void *buf; /* Data to be written */
  118. int cnt; /* Count */
  119. int attrib; /* Screen attribute to be used */
  120. {
  121. uint8 *buf1 = buf;
  122. uint8 *sp = bufloc(dp,dp->slast+1,col);
  123. struct dirty *dirtp = &dp->dirty[dp->slast+1];
  125. /* Clip debug area if activated */
  126. if(Kdebug && cnt > DCOL - col - 1)
  127. cnt = DCOL - col - 1;
  128. else if(cnt > dp->cols-col)
  129. cnt = dp->cols - col; /* Limit write to line length */
  131. while(cnt-- != 0){
  132. if(sp[0] != *buf1 || sp[1] != attrib){
  133. if(col < dirtp->lcol)
  134. dirtp->lcol = col; 
  135. if(col > dirtp->rcol)
  136. dirtp->rcol = col;
  137. sp[0] = *buf1;
  138. sp[1] = attrib;
  139. }
  140. buf1++;
  141. sp += 2;
  142. col++;
  143. }
  144. }
  145. /* Write data to the virtual display. Does NOT affect the real screen -
  146.  * dupdate(dp) must be called to copy the virtual screen to the real
  147.  * screen.
  148.  */
  149. void
  150. displaywrite(dp,buf,cnt)
  151. struct display *dp; /* Virtual screen pointer */
  152. void *buf; /* Data to be written */
  153. int cnt; /* Count */
  154. {
  155. uint8 c;
  156. char *bufp = buf;
  158. if(dp == NULL || dp->cookie != D_COOKIE)
  159. return;
  161. while(cnt-- != 0){
  162. c = *bufp++;
  163. switch(dp->state){
  164. case DISP_ESCAPE:
  165. desc(dp,c);
  166. break;
  167. case DISP_ARG:
  168. darg(dp,c);
  169. break;
  170. case DISP_NORMAL:
  171. dchar(dp,c);
  172. break;
  173. }
  174. }
  175. ksignal(dp,1);
  176. }
  177. /* Make the real screen look like the virtual one. It attempts to do as
  178.  * little work as possible unless the "dirty screen" flag is set -- then
  179.  * the entire screen is updated. (This is useful when switching between
  180.  * virtual display screens.)
  181.  *
  182.  * Note the different row and column numbering conventions -- I start
  183.  * at zero, the puttext() and gotoxy() library functions start at 1.
  184.  */
  185. void
  186. dupdate(dp)
  187. struct display *dp; /* Virtual screen pointer */
  188. {
  189. int row,rows;
  190. long sp;
  191. uint8 *lbuf;
  192. struct dirty *dirtp;
  193. long offset;
  195. if(dp == NULL || dp->cookie != D_COOKIE)
  196. return;
  198. offset = dp->flags.scrollbk ? dp->sfoffs : 0;
  200. if(offset > 0 && dp->flags.dirty_screen){
  201. /* Display from scrollback file */
  202. sp = dp->sfseek - 2*offset*dp->cols;
  203. if(sp < 0)
  204. sp += 2*dp->sfsize*dp->cols; /* Wrap back */
  205. rows = min(offset,dp->slast+1); /* # rows to read */
  206. lbuf = malloc(2*dp->cols*rows);
  207. fseek(dp->sfile,sp,SEEK_SET);
  208. /* row = actual # rows read */
  209. row = fread(lbuf,2*dp->cols,rows,dp->sfile);
  210. if(row != 0)
  211. puttext(1,1,dp->cols,row,lbuf);
  212. if(row != rows){
  213. /* Hit end of file; rewind and read the rest */
  214. fseek(dp->sfile,0L,SEEK_SET);
  215. fread(lbuf,2*dp->cols,rows-row,dp->sfile);
  216. puttext(1,row+1,dp->cols,rows,lbuf);
  217. }
  218. free(lbuf);
  219. }
  220. /* Display from memory image of current screen (if visible) */
  221. for(row = offset,dirtp = &dp->dirty[row];
  222.  row<=dp->slast;row++,dirtp++){
  223. if(dp->flags.dirty_screen){
  224. /* Force display of all columns */
  225. dirtp->lcol = 0;
  226. dirtp->rcol = dp->cols-1;
  227. }
  228. if(dirtp->lcol <= dirtp->rcol){
  229. puttext(dirtp->lcol+1,row+1,dirtp->rcol+1,row+1,
  230.  bufloc(dp,row-offset,dirtp->lcol));
  231. dirtp->lcol = dp->cols-1;
  232. dirtp->rcol = 0;
  233. }
  234. }
  235. /* Display unscrolled status region */
  236. for(row=dp->slast+1,dirtp = &dp->dirty[row];row<dp->rows;row++,dirtp++){
  237. if(dp->flags.dirty_screen){
  238. dirtp->lcol = 0;
  239. dirtp->rcol = dp->cols-1;
  240. }
  241. if(dirtp->lcol <= dirtp->rcol){
  242. puttext(dirtp->lcol+1,row+1,dirtp->rcol+1,row+1,
  243.  bufloc(dp,row,dirtp->lcol));
  244. dirtp->lcol = dp->cols-1;
  245. dirtp->rcol = 0;
  246. }
  247. }
  248. if(dp->flags.dirty_screen || (dp->flags.dirty_cursor)){
  249. /* Update cursor */
  250. if(dp->row+offset <= dp->slast){
  251. gotoxy(dp->col+1,dp->row+1+offset);
  252. _setcursortype(_NORMALCURSOR);
  253. } else {
  254. /* Turn off cursor entirely */
  255. _setcursortype(_NOCURSOR);
  256. }
  257. }
  258. dp->flags.dirty_cursor = 0;
  259. dp->flags.dirty_screen = 0;
  260. }
  261. void
  262. dscrollmode(dp,flag)
  263. struct display *dp;
  264. int flag;
  265. {
  266. if(dp == NULL || dp->cookie != D_COOKIE)
  267. return;
  269. if(flag != dp->flags.scrollbk){
  270. dp->flags.scrollbk = flag;
  271. if(dp->sfoffs != 0)
  272. dp->flags.dirty_screen = 1;
  273. alert(Display,1);
  274. }
  275. }
  278. void
  279. dhome(dp)
  280. struct display *dp;
  281. {
  282. if(dp == NULL || dp->cookie != D_COOKIE)
  283. return;
  285. if(dp->sfoffs != dp->sfsize){
  286. dp->sfoffs = dp->sfsize;
  287. dp->flags.dirty_screen = 1;
  288. alert(Display,1);
  289. }
  290. }
  291. void
  292. dend(dp)
  293. struct display *dp;
  294. {
  295. if(dp == NULL || dp->cookie != D_COOKIE)
  296. return;
  298. if(dp->sfoffs != 0){
  299. dp->sfoffs = 0;
  300. dp->flags.dirty_screen = 1;
  301. alert(Display,1);
  302. }
  303. }
  304. void
  305. dpgup(dp)
  306. struct display *dp;
  307. {
  308. long newoffs;
  310. if(dp == NULL || dp->cookie != D_COOKIE)
  311. return;
  313. newoffs = dp->sfoffs + dp->slast + 1;
  314. newoffs = min(newoffs,dp->sfsize);
  315. if(newoffs != dp->sfoffs){
  316. dp->sfoffs = newoffs;
  317. dp->flags.dirty_screen = 1;
  318. alert(Display,1);
  319. }
  320. }
  321. void
  322. dpgdown(dp)
  323. struct display *dp;
  324. {
  325. long newoffs;
  327. if(dp == NULL || dp->cookie != D_COOKIE)
  328. return;
  330. newoffs = dp->sfoffs - (dp->slast + 1);
  331. newoffs = max(0,newoffs);
  332. if(newoffs != dp->sfoffs){
  333. dp->sfoffs = newoffs;
  334. dp->flags.dirty_screen = 1; 
  335. alert(Display,1);
  336. }
  337. }
  338. void
  339. dcursup(dp)
  340. struct display *dp;
  341. {
  342. if(dp == NULL || dp->cookie != D_COOKIE)
  343. return;
  345. if(dp->sfoffs < dp->sfsize){
  346. dp->sfoffs++;
  347. dp->flags.dirty_screen = 1; 
  348. alert(Display,1);
  349. }
  350. }
  351. void
  352. dcursdown(dp)
  353. struct display *dp;
  354. {
  355. if(dp == NULL || dp->cookie != D_COOKIE)
  356. return;
  358. if(dp->sfoffs != 0){
  359. dp->sfoffs--;
  360. dp->flags.dirty_screen = 1; 
  361. alert(Display,1);
  362. }
  363. }
  365. /* Process incoming character while in ESCAPE state */
  366. static void
  367. desc(dp,c)
  368. struct display *dp;
  369. uint8 c;
  370. {
  371. int i;
  373. switch(c){
  374. case 'O':
  375. case '[': /* Always second char of ANSI escape sequence */
  376. /* Get ready for argument list */
  377. dp->state = DISP_ARG;
  378. dp->argi = 0;
  379. for(i=0;i<MAXARGS;i++)
  380. dp->arg[i] = 0;
  382. break;
  383. case '7': /* Save cursor location (VT-100) */
  384. dp->savcol = dp->col;
  385. dp->savrow = dp->row;
  386. dp->state = DISP_NORMAL;
  387. break;
  388. case '8': /* Restore cursor location (VT-100) */
  389. dp->col = dp->savcol;
  390. dp->row = dp->savrow;
  391. dp->flags.dirty_cursor = 1;
  392. dp->state = DISP_NORMAL;
  393. break;
  394. case ESC:
  395. break; /* Remain in ESCAPE state */
  396. case 'H': /* Set tab stop at current position (VT-100) */
  397. dp->tabstops[dp->col] = 1;
  398. break;
  399. default:
  400. dp->state = DISP_NORMAL;
  401. dchar(dp,c);
  402. }
  403. }
  405. /* Process characters after a ESC[ sequence */
  406. static void
  407. darg(dp,c)
  408. struct display *dp;
  409. uint8 c;
  410. {
  411. int i;
  413. switch(c){
  414. case ESC:
  415. dp->state = DISP_ESCAPE;
  416. return;
  417. case '?': /* Ignored */
  418. case '=':
  419. return;
  420. case '0':
  421. case '1':
  422. case '2':
  423. case '3':
  424. case '4':
  425. case '5':
  426. case '6':
  427. case '7':
  428. case '8':
  429. case '9':
  430. /* Collect decimal number */
  431. dp->arg[dp->argi] = 10*dp->arg[dp->argi] + (c - '0');
  432. return;
  433. case ';': /* Next argument is beginning */
  434. if(dp->argi <= MAXARGS - 1)
  435. dp->argi++;
  436. dp->arg[dp->argi] = 0;
  437. return;
  438. case '@': /* Open up space for character */
  439. dinsert(dp);
  440. break;
  441. case 'A': /* Cursor up */
  442. if(dp->arg[0] == 0)
  443. dp->arg[0] = 1; /* Default is one line */
  444. if(dp->arg[0] <= dp->row)
  445. dp->row -= dp->arg[0];
  446. else
  447. dp->row = 0;
  448. dp->flags.dirty_cursor = 1;
  449. break;
  450. case 'B': /* Cursor down */
  451. if(dp->arg[0] == 0)
  452. dp->arg[0] = 1; /* Default is one line */
  453. dp->row += dp->arg[0];
  454. if(dp->row > dp->slast)
  455. dp->row = dp->slast;
  456. dp->flags.dirty_cursor = 1; 
  457. break;
  458. case 'C': /* Cursor right */
  459. if(dp->arg[0] == 0)
  460. dp->arg[0] = 1; /* Default is one column */
  461. dp->col += dp->arg[0];
  462. if(dp->col >= dp->cols)
  463. dp->col = dp->cols - 1;
  464. dp->flags.dirty_cursor = 1;
  465. break;
  466. case 'D': /* Cursor left */
  467. if(dp->arg[0] == 0)
  468. dp->arg[0] = 1; /* Default is one column */
  469. if(dp->arg[0] <= dp->col)
  470. dp->col -= dp->arg[0];
  471. else
  472. dp->col = 0;
  473. dp->flags.dirty_cursor = 1;
  474. break;
  475. case 'f':
  476. case 'H': /* Cursor motion - limit to scrolled region */
  477. i = (dp->arg[0] == 0) ? 0 : dp->arg[0] - 1;
  478. if(i > dp->slast)
  479. i = dp->slast;
  480. dp->row = i;
  482. i = (dp->arg[1] == 0) ? 0 : dp->arg[1] - 1;
  483. if(i >= dp->cols)
  484. i = dp->cols - 1;
  485. dp->col = i;
  486. dp->state = DISP_NORMAL;
  487. dp->flags.dirty_cursor = 1;
  488. break;
  489. case 'h': /* Set mode */
  490. switch(dp->arg[0]){
  491. case 7: /* Turn on wrap mode */
  492. dp->flags.no_line_wrap = 0;
  493. break;
  494. }
  495. break;
  496. case 'J': /* Clear screen */
  497. switch(dp->arg[0]){
  498. case 2:
  499. dclrscr(dp); /* Clear entire screen, home cursor */
  500. break;
  501. case 0:
  502. dclreod(dp,dp->row,dp->col); /* Clear to end of screen (VT-100) */
  503. break;
  504. }
  505. break;
  506. case 'K': /* Erase to end of current line */
  507. dclreol(dp,dp->row,dp->col);
  508. break;
  509. case 'L': /* Add blank line */
  510. dinsline(dp);
  511. break;
  512. case 'l': /* Clear mode */
  513. switch(dp->arg[0]){
  514. case 7: /* Turn off wrap mode */
  515. dp->flags.no_line_wrap = 1;
  516. break;
  517. }
  518. break;
  519. case 'M': /* Delete line */
  520. ddelline(dp);
  521. break;
  522. case 'm': /* Set screen attributes */
  523. for(i=0;i<=dp->argi;i++){
  524. dattrib(dp,dp->arg[i]);
  525. }
  526. break;
  527. case 'P': /* Delete character */
  528. ddelchar(dp);
  529. break;
  530. case 's': /* Save cursor position */
  531. dp->savcol = dp->col;
  532. dp->savrow = dp->row;
  533. break;
  534. case 'u': /* Restore cursor position */
  535. dp->col = dp->savcol;
  536. dp->row = dp->savrow;
  537. dp->flags.dirty_cursor = 1;
  538. break;
  539. case 'g':
  540. switch(dp->arg[0]){
  541. case 0:
  542. dp->tabstops[dp->col] = 0;
  543. break;
  544. case 3:
  545. memset(dp->tabstops,0,dp->cols);
  546. break;
  547. }
  548. break;
  549. }
  550. dp->state = DISP_NORMAL;
  551. }
  552. /* Clear from specified location to end of screen, leaving cursor as is */
  553. static void
  554. dclreod(dp,row,col)
  555. struct display *dp;
  556. int row,col;
  557. {
  558. dclreol(dp,row,col); /* Clear current line */
  559. for(row = row + 1;row <= dp->slast;row++)
  560. dclreol(dp,row,0); /* Clear all lines below */
  561. }
  562. /* Insert space at cursor, moving all chars on right to right one position */
  563. static void
  564. dinsert(dp)
  565. struct display *dp;
  566. {
  567. int i = 2*(dp->cols - dp->col - 1);
  568. uint8 *cp = bufloc(dp,dp->row,dp->col);
  569. struct dirty *dirtp = &dp->dirty[dp->row];
  571. if(i != 0)
  572. memmove(cp+2,cp,i); /* handles overlapping blocks */
  573. *cp++ = ' ';
  574. *cp = dp->attrib;
  575. /* Dirty everything from the cursor to the right edge */
  576. if(dp->col < dirtp->lcol)
  577. dirtp->lcol = dp->col;
  578. dirtp->rcol = dp->cols-1;
  579. }
  580. /* Delete character at cursor, moving chars to right left one position */
  581. static void
  582. ddelchar(dp)
  583. struct display *dp;
  584. {
  585. uint8 *cp = bufloc(dp,dp->row,dp->col);
  586. int i = 2*(dp->cols-dp->col-1);
  587. struct dirty *dirtp = &dp->dirty[dp->row];
  589. /* Copy characters to right one space left */
  590. if(i != 0)
  591. memmove(cp,cp+2,i); /* memmove handles overlapping blocks */
  592. /* Clear right most character on line */
  593. cp[i] = ' ';
  594. cp[i+1] = dp->attrib;
  595. /* Dirty everything from the cursor to the right edge */
  596. if(dp->col < dirtp->lcol)
  597. dirtp->lcol = dp->col;
  598. dirtp->rcol = dp->cols-1;
  599. }
  600. /* Delete line containing cursor, moving lines below up one line */
  601. static void
  602. ddelline(dp)
  603. struct display *dp;
  604. {
  605. uint8 *cp1,*cp2;
  606. int row;
  607. struct dirty *dirtp;
  609. for(row=dp->row,dirtp = &dp->dirty[row];row < dp->slast;row++,dirtp++){
  610. cp1 = bufloc(dp,row,0);
  611. cp2 = bufloc(dp,row+1,0);
  612. memcpy(cp1,cp2,dp->cols*2);
  613. /* Dirty entire line */
  614. dirtp->lcol = 0;
  615. dirtp->rcol = dp->cols-1;
  616. }
  617. /* Clear bottom line */
  618. dclreol(dp,dp->slast,0);
  619. }
  620. /* Insert blank line where cursor is. Push existing lines down one */
  621. static void
  622. dinsline(dp)
  623. struct display *dp;
  624. {
  625. uint8 *cp1,*cp2;
  626. int row;
  627. struct dirty *dirtp;
  629. /* Copy lines down */
  630. for(row = dp->slast,dirtp = &dp->dirty[row];row > dp->row;row--){
  631. cp1 = bufloc(dp,row-1,0);
  632. cp2 = bufloc(dp,row,0);
  633. memcpy(cp2,cp1,2*dp->cols);
  634. /* Dirty entire line */
  635. dirtp->lcol = 0;
  636. dirtp->rcol = dp->cols-1;
  637. }
  638. /* Clear current line */
  639. dclreol(dp,dp->row,0);
  640. }
  642. /* Process an argument to an attribute set command */
  643. static void
  644. dattrib(dp,val)
  645. struct display *dp;
  646. int val;
  647. {
  648. switch(val){
  649. case 0: /* Normal white on black */
  650. dp->attrib = 0x7;
  651. break;
  652. case 1: /* High intensity */
  653. dp->attrib |= 0x8;
  654. break;
  655. case 5: /* Blink on */
  656. dp->attrib |= 0x80;
  657. break;
  658. case 7: /* Reverse video (black on white) */
  659. dp->attrib = 0x70;
  660. break;
  661. default:
  662. if(val >= 30 && val < 38){
  663. /* Set foreground color */
  664. dp->attrib = (dp->attrib & ~0x7) | fgattr[val - 30];
  665. } else if(val >= 40 && val < 48){
  666. /* Set background color */
  667. dp->attrib = (dp->attrib & ~0x70) | ((bgattr[val - 40]) << 4);
  668. }
  669. break;
  670. }
  671.  }
  672. /* Display character */
  673. static void
  674. dchar(dp,c)
  675. struct display *dp;
  676. uint8 c;
  677. {
  678. uint8 *cp;
  679. int row,rowchange;
  680. struct dirty *dirtp;
  682. rowchange = 0;
  683. switch(c){
  684. case ESC:
  685. dp->state = DISP_ESCAPE;
  686. return;
  687. case CTLQ: /*****/
  688. case '': /* Ignore nulls and bells */
  689. case BELL:
  690. break;
  691. case 'b': /* Backspace */
  692. if(dp->col > 0){
  693. dp->col--;
  694. dp->flags.dirty_cursor = 1;
  695. }
  696. break;
  697. case FF: /* Page feed */
  698. dclrscr(dp);
  699. break;
  700. case 't': /* Tab */
  701. while(dp->col < dp->cols-1){
  702. if(dp->tabstops[++dp->col])
  703. break;
  704. }
  705. dp->flags.dirty_cursor = 1;
  706. break;
  707. case 'n': /* Move cursor down one row */
  708. dp->row++;
  709. rowchange = 1;
  710. dp->flags.dirty_cursor = 1;
  711. break;
  712. case 'r': /* Move cursor to beginning of current row */
  713. dp->col = 0;
  714. dp->flags.dirty_cursor = 1;
  715. break;
  716. default: /* Display character on screen */
  717. /* Compute location in screen buffer memory */
  718. cp = bufloc(dp,dp->row,dp->col);
  719. /* Normal display */
  720. if(c != *cp || cp[1] != dp->attrib){
  721. dirtp = &dp->dirty[dp->row];
  722. if(dp->col < dirtp->lcol)
  723. dirtp->lcol = dp->col;
  724. if(dp->col > dirtp->rcol)
  725. dirtp->rcol = dp->col;
  726. }
  727. *cp++ = c;
  728. *cp = dp->attrib;
  729. dp->flags.dirty_cursor = 1;
  730. /* Update cursor position, wrapping if necessary */
  731. if(++dp->col == dp->cols){
  732. if(dp->flags.no_line_wrap){
  733. dp->col--;
  734. } else {
  735. dp->col = 0;
  736. dp->row++;
  737. rowchange = 1;
  738. }
  739. }
  740. }
  741. /* Scroll screen if necessary */
  742. if(rowchange && dp->row > dp->slast){
  743. dp->row--;
  744. /* Scroll screen up */
  745. dp->scroll = (dp->scroll + 1) % (dp->slast + 1);
  746. if(!dp->flags.no_scroll){
  747. for(row=0,dirtp=&dp->dirty[row];row <=dp->slast;row++,dirtp++){
  748. dirtp->lcol = 0;
  749. dirtp->rcol = dp->cols-1;
  750. }
  751. }
  752. if(dp->sfile != NULL){
  753. uint8 *cp;
  755. /* When scrolled back, leave screen stationary */
  756. if(dp->flags.scrollbk && dp->sfoffs != dp->sflimit)
  757. dp->sfoffs++;
  759. /* Copy scrolled line to scrollback file */
  760. cp = bufloc(dp,dp->row,0);
  761. fseek(dp->sfile,dp->sfseek,SEEK_SET);
  762. fwrite(cp,2,dp->cols,dp->sfile);
  763. dp->sfseek += 2*dp->cols;
  764. if(dp->sfseek >= 2*dp->cols*dp->sflimit)
  765. dp->sfseek = 0;
  766. if(dp->sfsize < dp->sflimit)
  767. dp->sfsize++;
  768. }
  769. dclreol(dp,dp->row,0);
  770. }
  771. }
  773. /* Clear from specified location to end of line. Cursor is not moved */
  774. static void
  775. dclreol(dp,row,col)
  776. struct display *dp;
  777. int row,col;
  778. {
  779. uint8 *cp = bufloc(dp,row,col);
  780. struct dirty *dirtp = &dp->dirty[row];
  781. int i;
  783. for(i=dp->cols - col;i!=0;i--){
  784. *cp++ = ' ';
  785. *cp++ = dp->attrib;
  786. }
  787. /* Dirty from current column to right edge */
  788. if(col < dirtp->lcol)
  789. dirtp->lcol = col;
  790. dirtp->rcol = dp->cols-1;
  791. }
  792. /* Move cursor to top left corner, clear screen */
  793. static void
  794. dclrscr(dp)
  795. struct display *dp;
  796. {
  797. dclreod(dp,0,0);
  798. dp->row = dp->col = 0;
  799. dp->scroll = 0;
  800. dp->flags.dirty_cursor = 1;
  801. }
  802. /* Return pointer into screen buffer for specified cursor location.
  803.  * Not guaranteed to be valid past the end of the current line due to
  804.  * scrolling
  805.  */
  806. static uint8 *
  807. bufloc(dp,row,col)
  808. struct display *dp;
  809. int row,col;
  810. {
  811. #ifndef notdef
  812. if(row < 0 || row >= dp->rows || col < 0 || col >= dp->cols){
  813. stktrace();
  814. cprintf("panic: bufloc(%p,%d,%d)n",dp,row,col);
  815. exit(1);
  816. }
  817. #endif
  818. if(row <= dp->slast)
  819. row = (row + dp->scroll) % (dp->slast + 1);
  820. return dp->buf + 2*(col + dp->cols*row);
  821. }
  822. /* Immediately display short debug string on lower right corner of display */
  823. void
  824. debug(s)
  825. char *s;
  826. {
  827. int i;
  828. static uint8 msg[2*DSIZ];
  830. if(msg[1] != 0x7){
  831. /* One time initialization to blanks with white-on-black */
  832. for(i=0;i<DSIZ;i++){
  833. msg[2*i] = ' ';
  834. msg[2*i+1] = 0x7;
  835. }
  836. }
  837. if(s == NULL)
  838. return;
  839. for(i=0;i<DSIZ && *s != '';i++)
  840. msg[2*i] = (uint8) *s++;
  842. for(;i<DSIZ;i++)
  843. msg[2*i] = ' ';
  845. puttext(DCOL,25,80,25,msg);
  846. }