![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to datastream.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / tn3270|
Return to datastream.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / tn3270 |
1.1 ! root 1: /* ! 2: * Copyright 1984, 1985 by the Regents of the University of ! 3: * California and by Gregory Glenn Minshall. ! 4: * ! 5: * Permission to use, copy, modify, and distribute these ! 6: * programs and their documentation for any purpose and ! 7: * without fee is hereby granted, provided that this ! 8: * copyright and permission appear on all copies and ! 9: * supporting documentation, the name of the Regents of ! 10: * the University of California not be used in advertising ! 11: * or publicity pertaining to distribution of the programs ! 12: * without specific prior permission, and notice be given in ! 13: * supporting documentation that copying and distribution is ! 14: * by permission of the Regents of the University of California ! 15: * and by Gregory Glenn Minshall. Neither the Regents of the ! 16: * University of California nor Gregory Glenn Minshall make ! 17: * representations about the suitability of this software ! 18: * for any purpose. It is provided "as is" without ! 19: * express or implied warranty. ! 20: */ ! 21: ! 22: ! 23: /* this exists to patch over DataFromNetwork until it is ready */ ! 24: ! 25: #include <signal.h> ! 26: #include <sgtty.h> ! 27: #include <stdio.h> ! 28: #include <curses.h> ! 29: ! 30: #include "ascebc.h" ! 31: #include "3270.h" ! 32: #include "screen.h" ! 33: ! 34: #ifndef lint ! 35: static char sccsid[] = "@(#)datastream.c 2.12\t12/16/85"; ! 36: #endif /* lint */ ! 37: ! 38: void EmptyTerminal(); ! 39: ! 40: #define CorrectTerminalCursor() ((TransparentClock == OutputClock)? terminalCursorAddress:UnLocked? CursorAddress: HighestScreen()) ! 41: ! 42: #define SetHighestLowest(position) { \ ! 43: if (position < Lowest) { \ ! 44: Lowest = position; \ ! 45: } \ ! 46: if (position > Highest) { \ ! 47: Highest = position; \ ! 48: } \ ! 49: } ! 50: ! 51: extern char ebcasc[NEBCASC][NEBC]; /* translate table */ ! 52: ! 53: static int terminalCursorAddress; /* where the cursor is on term */ ! 54: static int screenInitd; /* the screen has been initialized */ ! 55: static int MAX_CHANGES_BEFORE_POLL; /* how many characters before looking */ ! 56: /* at terminal and net again */ ! 57: ! 58: static int needToRing = 0; /* need to ring terinal bell */ ! 59: static char *bellSequence = "\07"; /* bell sequence (may be replaced by ! 60: * VB during initialization) ! 61: */ ! 62: static char *KS, *KE; /* Turn on and off keyboard */ ! 63: ! 64: static char Blanks[sizeof Terminal]; /* lots of blanks */ ! 65: ! 66: /* some globals */ ! 67: ! 68: int OutputClock; /* what time it is */ ! 69: int TransparentClock; /* time we were last in transparent */ ! 70: ! 71: ! 72: /* StartScreen - called to initialize the screen, etc. */ ! 73: ! 74: StartScreen() ! 75: { ! 76: int save; ! 77: struct sgttyb ourttyb; ! 78: static int speeds[] = { 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, ! 79: 2400, 4800, 9600 }; ! 80: static char KSEbuffer[2050]; ! 81: char *lotsofspace = KSEbuffer, *tgetstr(); ! 82: ! 83: if (!screenInitd) { ! 84: ioctl(1, TIOCGETP, (char *) &ourttyb); ! 85: if ((ourttyb.sg_ospeed < 0) || (ourttyb.sg_ospeed > B9600)) { ! 86: MAX_CHANGES_BEFORE_POLL = 1920; ! 87: } else { ! 88: MAX_CHANGES_BEFORE_POLL = speeds[ourttyb.sg_ospeed]/10; ! 89: if (MAX_CHANGES_BEFORE_POLL < 40) { ! 90: MAX_CHANGES_BEFORE_POLL = 40; ! 91: } ! 92: } ! 93: save = mode(0); ! 94: initscr(); /* start up curses */ ! 95: nonl(); ! 96: /* the problem is that curses catches SIGTSTP to ! 97: * be nice, but it messes us up. ! 98: */ ! 99: signal(SIGTSTP, SIG_DFL); ! 100: KS = tgetstr("ks", &lotsofspace); ! 101: KE = tgetstr("ke", &lotsofspace); ! 102: if (KS) { ! 103: StringToTerminal(KS); ! 104: } ! 105: DoARefresh(); ! 106: (void) mode(save); ! 107: if (VB && *VB) { ! 108: bellSequence = VB; /* use visual bell */ ! 109: } ! 110: screenInitd = 1; ! 111: } ! 112: } ! 113: ! 114: ! 115: ! 116: /* Stop3270 - called when we are going away... */ ! 117: ! 118: Stop3270(doNewLine) ! 119: int doNewLine; ! 120: { ! 121: if (screenInitd) { ! 122: int save; ! 123: ! 124: move(NUMBERLINES-1, 1); ! 125: DoARefresh(); ! 126: if (KE) { ! 127: StringToTerminal(KE); ! 128: } ! 129: if (doNewLine) { ! 130: StringToTerminal("\r\n"); ! 131: } ! 132: EmptyTerminal(); ! 133: save = mode(0); ! 134: endwin(); ! 135: (void) mode(save); ! 136: } ! 137: } ! 138: ! 139: ! 140: /* ConnectScreen - called to reconnect to the screen */ ! 141: ! 142: ConnectScreen() ! 143: { ! 144: if (screenInitd) { ! 145: if (KS) { ! 146: StringToTerminal(KS); ! 147: } ! 148: RefreshScreen(); ! 149: TryToSend(); ! 150: } ! 151: } ! 152: ! 153: /* RefreshScreen - called to cause the screen to be refreshed */ ! 154: ! 155: RefreshScreen() ! 156: { ! 157: clearok(curscr, TRUE); ! 158: TryToSend(); ! 159: } ! 160: ! 161: ! 162: /* Clear3270 - called to clear the screen */ ! 163: ! 164: Clear3270() ! 165: { ! 166: bzero((char *)Host, sizeof(Host)); ! 167: DeleteAllFields(); /* get rid of all fields */ ! 168: BufferAddress = SetBufferAddress(0,0); ! 169: CursorAddress = SetBufferAddress(0,0); ! 170: Lowest = LowestScreen(); ! 171: Highest = HighestScreen(); ! 172: } ! 173: ! 174: /* LocalClear3270() - clear the whole ball of wax, cheaply */ ! 175: ! 176: LocalClear3270() ! 177: { ! 178: outputPurge(); /* flush all data to terminal */ ! 179: clear(); /* clear in curses */ ! 180: bzero((char *)Terminal, sizeof Terminal); ! 181: Clear3270(); /* clear host part */ ! 182: Lowest = HighestScreen()+1; /* everything in sync... */ ! 183: Highest = LowestScreen()+1; ! 184: } ! 185: ! 186: /* OurExitString - designed to keep us from going through infinite recursion */ ! 187: ! 188: OurExitString(file, string, value) ! 189: FILE *file; ! 190: char *string; ! 191: int value; ! 192: { ! 193: static int recursion = 0; ! 194: ! 195: if (!recursion) { ! 196: recursion = 1; ! 197: ExitString(file, string, value); ! 198: } ! 199: } ! 200: ! 201: ! 202: RingBell() ! 203: { ! 204: needToRing = 1; ! 205: } ! 206: ! 207: /* AddHost - called to add a character to the buffer. ! 208: * We use a macro in this module, since we call it so ! 209: * often from loops. ! 210: * ! 211: * NOTE: It is a macro, so don't go around using AddHost(p, *c++), or ! 212: * anything similar. (I don't define any temporary variables, again ! 213: * just for the speed.) ! 214: */ ! 215: AddHost(position, character) ! 216: int position; ! 217: char character; ! 218: { ! 219: # define AddHostA(p,c) \ ! 220: { \ ! 221: if (IsStartField(p)) { \ ! 222: DeleteField(p); \ ! 223: SetHighestLowest(p); \ ! 224: } \ ! 225: SetHost(p, c); \ ! 226: } ! 227: # define AddHost(p,c) \ ! 228: { \ ! 229: AddHostA(p,c); \ ! 230: if ((c != GetTerminal(p)) || TermIsStartField(p)) { \ ! 231: SetHighestLowest(p); \ ! 232: } \ ! 233: } /* end of macro of AddHost */ ! 234: ! 235: AddHost(position, character); ! 236: } ! 237: ! 238: /* DoARefresh */ ! 239: ! 240: static ! 241: DoARefresh() ! 242: { ! 243: if (ERR == refresh()) { ! 244: OurExitString(stderr, "ERR from refresh\n", 1); ! 245: } ! 246: } ! 247: ! 248: /* TryToSend - send data out to user's terminal */ ! 249: ! 250: static ! 251: TryToSend() ! 252: { ! 253: register int pointer; ! 254: register int c; ! 255: register int fieldattr; ! 256: register int changes; ! 257: ! 258: static int inHighlightMode = 0; ! 259: extern int HaveInput; /* 1 if there is input to check out */ ! 260: ! 261: # define SetHighlightMode(p) { \ ! 262: if (!IsStartField(p) && IsHighlightedAttr(fieldattr)) { \ ! 263: if (!inHighlightMode) { \ ! 264: inHighlightMode = 1; \ ! 265: standout(); \ ! 266: } \ ! 267: } else { \ ! 268: if (inHighlightMode) { \ ! 269: inHighlightMode = 0; \ ! 270: standend(); \ ! 271: } \ ! 272: } \ ! 273: } ! 274: ! 275: # define DoCharacterAt(c,p) { \ ! 276: SetTerminal(p, c); \ ! 277: if (p != HighestScreen()) { \ ! 278: c = TerminalCharacterAttr(ebcasc[0][c&0xff], p, \ ! 279: fieldattr); \ ! 280: if (terminalCursorAddress != p) { \ ! 281: if (ERR == mvaddch(ScreenLine(p), \ ! 282: ScreenLineOffset(p), c)) {\ ! 283: char foo[100]; \ ! 284: \ ! 285: sprintf(foo, "ERR from mvaddch at %d (%d, %d)\n", \ ! 286: p, ScreenLine(p), ScreenLineOffset(p)); \ ! 287: OurExitString(stderr, foo, 1); \ ! 288: } \ ! 289: } else { \ ! 290: if (ERR == addch(c)) {\ ! 291: char foo[100]; \ ! 292: \ ! 293: sprintf(foo, "ERR from addch at %d (%d, %d)\n", \ ! 294: p, ScreenLine(p), ScreenLineOffset(p)); \ ! 295: OurExitString(stderr, foo, 1); \ ! 296: } \ ! 297: } \ ! 298: terminalCursorAddress = ScreenInc(p); \ ! 299: } \ ! 300: /* if (pointer%LINESIZE == LINESIZE-1) { \ ! 301: DoARefresh(); \ ! 302: if (TtyChars() > MAX_CHANGES_BEFORE_POLL) { \ ! 303: EmptyTerminal(); \ ! 304: } \ ! 305: } */ \ ! 306: } ! 307: ! 308: /* run through screen, printing out non-null lines */ ! 309: ! 310: /* There are two separate reasons for wanting to terminate this ! 311: * loop early. One is to respond to new input (either from ! 312: * the terminal or from the network [host]). For this reason, ! 313: * we expect to see 'HaveInput' come true when new input comes in. ! 314: * ! 315: * The second reason is a bit more difficult (for me) to understand. ! 316: * Basically, we don't want to get too far ahead of the characters that ! 317: * appear on the screen. Ideally, we would type out a few characters, ! 318: * wait until they appeared on the screen, then type out a few more. ! 319: * The reason for this is that the user, on seeing some characters ! 320: * appear on the screen may then start to type something. We would ! 321: * like to look at what the user types at about the same 'time' ! 322: * (measured by characters being sent to the terminal) that the ! 323: * user types them. For this reason, what we would like to do ! 324: * is update a bit, then call curses to do a refresh, flush the ! 325: * output to the terminal, then wait until the terminal data ! 326: * has been sent. ! 327: * ! 328: * Note that curses is useful for, among other things, deciding whether ! 329: * or not to send :ce: (clear to end of line), so we should call curses ! 330: * at end of lines (beginning of next lines). ! 331: * ! 332: * The problems here are the following: If we do lots of write(2)s, ! 333: * we will be doing lots of context switches, thus lots of overhead ! 334: * (which we have already). Second, if we do a select to wait for ! 335: * the output to drain, we have to contend with the fact that NOW ! 336: * we are scheduled to run, but who knows what the scheduler will ! 337: * decide when the output has caught up. ! 338: */ ! 339: ! 340: if (Highest == HighestScreen()) { ! 341: Highest = ScreenDec(Highest); /* else, while loop will never end */ ! 342: } ! 343: if (Lowest < LowestScreen()) { ! 344: Lowest = LowestScreen(); /* could be -1 in some cases with ! 345: * unformatted screens. ! 346: */ ! 347: } ! 348: if (Highest >= Lowest) { ! 349: /* if there is anything to do, do it. We won't terminate ! 350: * the loop until we've gone at least to Highest. ! 351: */ ! 352: pointer = Lowest; ! 353: while ((pointer <= Highest) && !HaveInput) { ! 354: ! 355: /* point at the next place of disagreement */ ! 356: pointer += (bunequal(Host+pointer, Terminal+pointer, ! 357: (Highest-pointer+1)*sizeof Host[0])/sizeof Host[0]); ! 358: ! 359: /* how many characters to change until the end of the ! 360: * current line ! 361: */ ! 362: changes = LINESIZE - ScreenLineOffset(pointer); ! 363: ! 364: /* what is the field attribute of the current position */ ! 365: fieldattr = FieldAttributes(WhereAttrByte(pointer)); ! 366: ! 367: if ((IsStartField(pointer) != TermIsStartField(pointer)) || ! 368: (IsStartField(pointer) && ! 369: fieldattr != TermAttributes(pointer))) { ! 370: ! 371: int oldterm; ! 372: ! 373: oldterm = TermAttributes(pointer); ! 374: if (IsStartField(pointer)) { ! 375: TermNewField(pointer, fieldattr); ! 376: SetTerminal(pointer, 0); ! 377: } else { ! 378: TermDeleteField(pointer); ! 379: } ! 380: /* We always do the first character in a divergent ! 381: * field, since otherwise the start of a field in ! 382: * the Host structure may leave a highlighted blank ! 383: * on the screen, and the start of a field in the ! 384: * Terminal structure may leave a non-highlighted ! 385: * something in the middle of a highlighted field ! 386: * on the screen. ! 387: */ ! 388: SetHighlightMode(pointer); ! 389: c = GetHost(pointer); ! 390: DoCharacterAt(c,pointer); ! 391: ! 392: if (NotVisuallyCompatibleAttributes ! 393: (pointer, fieldattr, oldterm)) { ! 394: int j; ! 395: ! 396: j = pointer; ! 397: ! 398: pointer = ScreenInc(pointer); ! 399: SetHighlightMode(pointer); /* Turn on highlighting */ ! 400: while (!IsStartField(pointer) && ! 401: !TermIsStartField(pointer)) { ! 402: c = GetHost(pointer); ! 403: DoCharacterAt(c,pointer); /* MACRO */ ! 404: pointer = ScreenInc(pointer); ! 405: if (!(--changes)) { ! 406: DoARefresh(); ! 407: EmptyTerminal(); ! 408: /* We don't look at HaveInput here, since ! 409: * if we leave this loop before the end of ! 410: * the 3270 field, we could have pointer ! 411: * higher than Highest. This would cause ! 412: * us to end the highest "while" loop, ! 413: * but we may, in fact, need to go around the ! 414: * screen once again. ! 415: */ ! 416: } ! 417: /* The loop needs to be protected ! 418: * from the situation where there had been only ! 419: * one field on the Terminal, and none on the Host. ! 420: * In this case, we have just deleted our last ! 421: * field. Hence, the break. ! 422: */ ! 423: if (j == pointer) { ! 424: break; ! 425: } ! 426: } ! 427: if (!TermIsStartField(pointer)) { ! 428: /* Remember what the terminal looked like */ ! 429: TermNewField(pointer, oldterm); ! 430: SetTerminal(pointer, 0); ! 431: /* The danger here is that the current position may ! 432: * be the start of a Host field. If so, and the field ! 433: * is highlighted, and our terminal was highlighted, ! 434: * then we will leave a highlighted blank at this ! 435: * position. ! 436: */ ! 437: SetHighlightMode(pointer); ! 438: c = 0; ! 439: DoCharacterAt(c,pointer); ! 440: } ! 441: /* We could be in the situation of needing to exit. ! 442: * This could happen if the current field wrapped around ! 443: * the end of the screen. ! 444: */ ! 445: if (j > pointer) { ! 446: break; ! 447: } ! 448: } else { ! 449: c = GetHost(pointer); ! 450: /* We always do the first character in a divergent ! 451: * field, since otherwise the start of a field in ! 452: * the Host structure may leave a highlighted blank ! 453: * on the screen, and the start of a field in the ! 454: * Terminal structure may leave a non-highlighted ! 455: * something in the middle of a highlighted field ! 456: * on the screen. ! 457: */ ! 458: SetHighlightMode(pointer); ! 459: DoCharacterAt(c,pointer); ! 460: } ! 461: } else { ! 462: SetHighlightMode(pointer); ! 463: /* The following will terminate at least when we get back ! 464: * to the original 'pointer' location (since we force ! 465: * things to be equal). ! 466: */ ! 467: while (((c = GetHost(pointer)) != GetTerminal(pointer)) && ! 468: !IsStartField(pointer) && !TermIsStartField(pointer)) { ! 469: DoCharacterAt(c, pointer); ! 470: pointer = ScreenInc(pointer); ! 471: if (!(--changes)) { ! 472: DoARefresh(); ! 473: EmptyTerminal(); ! 474: if (HaveInput) { /* if input came in, take it */ ! 475: break; ! 476: } ! 477: } ! 478: } ! 479: } ! 480: } ! 481: } ! 482: DoARefresh(); ! 483: Lowest = pointer; ! 484: if (Lowest > Highest) { /* if we finished input... */ ! 485: Lowest = HighestScreen()+1; ! 486: Highest = LowestScreen()-1; ! 487: terminalCursorAddress = CorrectTerminalCursor(); ! 488: if (ERR == move(ScreenLine(terminalCursorAddress), ! 489: ScreenLineOffset(terminalCursorAddress))) { ! 490: OurExitString(stderr, "ERR from move\n", 1); ! 491: } ! 492: DoARefresh(); ! 493: if (needToRing) { ! 494: StringToTerminal(bellSequence); ! 495: needToRing = 0; ! 496: } ! 497: } ! 498: EmptyTerminal(); /* move data along */ ! 499: return; ! 500: } ! 501: ! 502: ! 503: /* returns a 1 if no more output available (so, go ahead and block), ! 504: or a 0 if there is more output available (so, just poll the other ! 505: sources/destinations, don't block). ! 506: */ ! 507: ! 508: int ! 509: DoTerminalOutput() ! 510: { ! 511: /* called just before a select to conserve IO to terminal */ ! 512: if (Initialized && ! 513: ((Lowest <= Highest) || needToRing || ! 514: (terminalCursorAddress != CorrectTerminalCursor()))) { ! 515: TryToSend(); ! 516: } ! 517: if (Lowest > Highest) { ! 518: return(1); /* no more output now */ ! 519: } else { ! 520: return(0); /* more output for future */ ! 521: } ! 522: } ! 523: ! 524: /* returns the number of characters consumed */ ! 525: int ! 526: DataFromNetwork(buffer, count, control) ! 527: register char *buffer; /* what the data is */ ! 528: register int count; /* and how much there is */ ! 529: int control; /* this buffer terminated block */ ! 530: { ! 531: int origCount; ! 532: register int c; ! 533: register int i; ! 534: static int Command; ! 535: static int Wcc; ! 536: static int LastWasTerminated = 0; /* was "control" = 1 last time? */ ! 537: ! 538: if (!Initialized) { /* not initialized */ ! 539: int abort(); ! 540: ! 541: bzero((char *)Host, sizeof Host); ! 542: DeleteAllFields(); ! 543: for (i = 0; i < sizeof Blanks; i++) { ! 544: Blanks[i] = ' '; ! 545: } ! 546: bzero((char *)Terminal, sizeof Terminal); ! 547: Lowest = HighestScreen()+1; ! 548: Highest = LowestScreen()-1; ! 549: terminalCursorAddress = ! 550: CursorAddress = ! 551: BufferAddress = SetBufferAddress(0,0); ! 552: UnLocked = 1; ! 553: StartScreen(); ! 554: LastWasTerminated = 1; ! 555: Initialized = 1; ! 556: OutputClock = 1; ! 557: TransparentClock = -1; ! 558: signal(SIGHUP, abort); ! 559: } ! 560: ! 561: origCount = count; ! 562: ! 563: if (LastWasTerminated) { ! 564: ! 565: if (count < 2) { ! 566: if (count == 0) { ! 567: StringToTerminal("Short count received from host!\n"); ! 568: return(count); ! 569: } ! 570: Command = buffer[0]&0xff; ! 571: switch (Command) { /* This had better be a read command */ ! 572: case CMD_READ_MODIFIED: ! 573: DoReadModified(); ! 574: break; ! 575: case CMD_READ_BUFFER: ! 576: DoReadBuffer(); ! 577: break; ! 578: default: ! 579: break; ! 580: } ! 581: return(1); /* We consumed everything */ ! 582: } ! 583: Command = buffer[0]&0xff; ! 584: Wcc = buffer[1]&0xff; ! 585: if (Wcc & WCC_RESET_MDT) { ! 586: i = c = WhereAttrByte(LowestScreen()); ! 587: do { ! 588: if (HasMdt(i)) { ! 589: TurnOffMdt(i); ! 590: } ! 591: i = FieldInc(i); ! 592: } while (i != c); ! 593: } ! 594: ! 595: switch (Command) { ! 596: case CMD_ERASE_WRITE: ! 597: Clear3270(); ! 598: if (TransparentClock == OutputClock) { ! 599: clearok(curscr, TRUE); ! 600: } ! 601: break; ! 602: case CMD_ERASE_ALL_UNPROTECTED: ! 603: CursorAddress = HighestScreen()+1; ! 604: for (i = LowestScreen(); i <= HighestScreen(); ScreenInc(i)) { ! 605: if (IsUnProtected(i)) { ! 606: if (CursorAddress > i) { ! 607: CursorAddress = i; ! 608: } ! 609: AddHost(i, '\0'); ! 610: } ! 611: if (HasMdt(i)) { ! 612: TurnOffMdt(i); ! 613: } ! 614: } ! 615: if (CursorAddress == HighestScreen()+1) { ! 616: CursorAddress = SetBufferAddress(0,0); ! 617: } ! 618: UnLocked = 1; ! 619: AidByte = 0; ! 620: break; ! 621: case CMD_WRITE: ! 622: break; ! 623: default: ! 624: break; ! 625: } ! 626: ! 627: count -= 2; /* strip off command and wcc */ ! 628: buffer += 2; ! 629: ! 630: } ! 631: LastWasTerminated = 0; /* then, reset at end... */ ! 632: ! 633: while (count) { ! 634: count--; ! 635: c = (*buffer++)&0xff; ! 636: if (IsOrder(c)) { ! 637: /* handle an order */ ! 638: switch (c) { ! 639: # define Ensure(x) if (count < x) { \ ! 640: if (!control) { \ ! 641: return(origCount-(count+1)); \ ! 642: } else { \ ! 643: /* XXX - should not occur */ \ ! 644: count = 0; \ ! 645: break; \ ! 646: } \ ! 647: } ! 648: case ORDER_SF: ! 649: Ensure(1); ! 650: c = (*buffer++)&0xff; ! 651: count--; ! 652: if ( ! (IsStartField(BufferAddress) && ! 653: FieldAttributes(BufferAddress) == c)) { ! 654: if (NotVisuallyCompatibleAttributes(BufferAddress, c, ! 655: FieldAttributes(BufferAddress))) { ! 656: SetHighestLowest(BufferAddress); ! 657: } ! 658: if (GetTerminal(BufferAddress)) { ! 659: SetHighestLowest(BufferAddress); ! 660: } ! 661: NewField(BufferAddress,c); ! 662: } ! 663: SetHost(BufferAddress, 0); ! 664: BufferAddress = ScreenInc(BufferAddress); ! 665: break; ! 666: case ORDER_SBA: ! 667: Ensure(2); ! 668: i = buffer[0]; ! 669: c = buffer[1]; ! 670: if (!i && !c) { /* transparent write */ ! 671: if (!control) { ! 672: return(origCount-(count+1)); ! 673: } else { ! 674: while (Initialized && ! 675: ((Lowest <= Highest) || needToRing || ! 676: (terminalCursorAddress != ! 677: CorrectTerminalCursor()))) { ! 678: extern int HaveInput; ! 679: ! 680: HaveInput = 0; ! 681: TryToSend(); ! 682: } ! 683: if (TransparentClock != OutputClock) { ! 684: if (!DoTerminalOutput()) { ! 685: return(origCount-(count+1)); ! 686: } ! 687: move(ScreenLine(CursorAddress), ! 688: ScreenLineOffset(CursorAddress)); ! 689: DoARefresh(); ! 690: } ! 691: TransparentClock = OutputClock; /* this clock */ ! 692: (void) DataToTerminal(buffer+2, count-2); ! 693: SendToIBM(); ! 694: TransparentClock = OutputClock+1; /* clock next */ ! 695: buffer += count; ! 696: count -= count; ! 697: } ! 698: } else { ! 699: BufferAddress = Addr3270(i, c); ! 700: buffer += 2; ! 701: count -= 2; ! 702: } ! 703: break; ! 704: case ORDER_IC: ! 705: CursorAddress = BufferAddress; ! 706: break; ! 707: case ORDER_PT: ! 708: for (i = ScreenInc(BufferAddress); (i != HighestScreen()); ! 709: i = ScreenInc(i)) { ! 710: if (IsStartField(i)) { ! 711: i = ScreenInc(i); ! 712: if (!IsProtected(ScreenInc(i))) { ! 713: break; ! 714: } ! 715: if (i == HighestScreen()) { ! 716: break; ! 717: } ! 718: } ! 719: } ! 720: CursorAddress = i; ! 721: break; ! 722: case ORDER_RA: ! 723: Ensure(2); ! 724: i = Addr3270(buffer[0], buffer[1]); ! 725: c = buffer[2]; ! 726: do { ! 727: AddHost(BufferAddress, c); ! 728: BufferAddress = ScreenInc(BufferAddress); ! 729: } while (BufferAddress != i); ! 730: buffer += 3; ! 731: count -= 3; ! 732: break; ! 733: case ORDER_EUA: /* (from [here,there), ie: half open interval] */ ! 734: Ensure(2); ! 735: c = FieldAttributes(WhereAttrByte(BufferAddress)); ! 736: for (i = Addr3270(buffer[0], buffer[1]); i != BufferAddress; ! 737: BufferAddress = ScreenInc(BufferAddress)) { ! 738: if (!IsProtectedAttr(BufferAddress, c)) { ! 739: AddHost(BufferAddress, 0); ! 740: } ! 741: } ! 742: buffer += 2; ! 743: count -= 2; ! 744: break; ! 745: case ORDER_YALE: /* special YALE defined order */ ! 746: Ensure(2); /* need at least two characters */ ! 747: if ((*buffer&0xff) == 0x5b) { ! 748: i = OptOrder(buffer+1, count-1, control); ! 749: if (i == 0) { ! 750: return(origCount-(count+1)); /* come here again */ ! 751: } else { ! 752: buffer += 1 + i; ! 753: count - = (1 + i); ! 754: } ! 755: } ! 756: break; ! 757: default: ! 758: break; /* XXX ? */ ! 759: } ! 760: if (count < 0) { ! 761: count = 0; ! 762: } ! 763: } else { ! 764: /* Data comes in large clumps - take it all */ ! 765: i = BufferAddress; ! 766: #ifdef NOTDEF ! 767: AddHost(i, c); ! 768: #else /* NOTDEF */ ! 769: AddHostA(i, c); ! 770: SetHighestLowest(i); ! 771: #endif /* NOTDEF */ ! 772: i = ScreenInc(i); ! 773: while (count && !IsOrder(c = *(buffer)&0xff)) { ! 774: buffer++; ! 775: #ifdef NOTDEF ! 776: AddHost(i, c); ! 777: #else /* NOTDEF */ ! 778: AddHostA(i, c); ! 779: #endif /* NOTDEF */ ! 780: i = ScreenInc(i); ! 781: #ifndef NOTDEF ! 782: if (i == LowestScreen()) { ! 783: SetHighestLowest(HighestScreen()); ! 784: } ! 785: #endif /* NOTDEF */ ! 786: count--; ! 787: } ! 788: #ifndef NOTDEF ! 789: SetHighestLowest(i); ! 790: #endif /* NOTDEF */ ! 791: BufferAddress = i; ! 792: } ! 793: } ! 794: if (count == 0) { ! 795: OutputClock++; /* time rolls on */ ! 796: if (control) { ! 797: if (Wcc & WCC_RESTORE) { ! 798: if (TransparentClock != OutputClock) { ! 799: AidByte = 0; ! 800: } ! 801: UnLocked = 1; ! 802: (void) TerminalIn(); /* move along user's input */ ! 803: } ! 804: if (Wcc & WCC_ALARM) { ! 805: RingBell(); ! 806: } ! 807: } ! 808: LastWasTerminated = control; /* state for next time */ ! 809: return(origCount); ! 810: } else { ! 811: return(origCount-count); ! 812: } ! 813: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.