cr_put.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*LINTLIBRARY*/
#ifndef lint
static char
#endif /* not lint */
#include <string.h>
#include "curses.ext"
#include <term.h>
#define HARDTABS 8
/* forward declarations */
/* should be static, but we may have prior application-dependency, sigh! */
void fgoto(void);
int plodput(char);
int plod(int);
int tabcol(int, int);
/*
* Terminal driving and line formatting routines.
* Basic motion optimizations are done here as well
* as formatting of lines (printing of control characters,
* line numbering and the like).
*/
/*
* Sync the position of the output cursor.
* Most work here is rounding for terminal boundaries getting the
* column position implied by wraparound or the lack thereof and
* rolling up the screen to get destline on the screen.
*/
int
{
#ifdef DEBUG
#endif
destcol = x;
destline = y;
fgoto();
return (OK);
}
void
fgoto(void)
{
char *cgp;
int l, c;
}
outline += l;
if (AM == 0) {
while (l > 0) {
if (_pfast)
if (CR)
else
(void) _putchar('\r');
if (NL)
else
(void) _putchar('\n');
l--;
}
outcol = 0;
}
}
}
l = destline;
c = destcol;
destcol = 0;
fgoto();
destcol = c;
}
while (l >= LINES) {
/*
* The following linefeed (or simulation thereof)
* is supposed to scroll up the screen, since we
* are on the bottom line. We make the assumption
* that linefeed will scroll. If ns is in the
* capability list this won't work. We should
* probably have an sc capability but sf will
* generally take the place if it works.
*
* Superbee glitch: in the middle of the screen we
* have to use esc B (down) because linefeed screws up
* in "Efficient Paging" (what a joke) mode (which is
* essential in some SB's because CRLF mode puts garbage
* in at end of memory), but you must use linefeed to
* scroll since down arrow won't go past memory end.
* I turned this off after recieving Paul Eggert's
* Superbee description which wins better.
*/
else
(void) _putchar('\n');
l--;
if (_pfast == 0)
outcol = 0;
}
}
if (CA) {
(void) plod(0);
else
}
else
(void) plod(0);
}
/*
* Move (slowly) to destination.
* Hard thing here is using home cursor on really deficient terminals.
* Otherwise just use cursor motions, hacking use of tabs and overtabbing
* and backspace.
*/
int
plodput(char c)
{
if (plodflg)
plodcnt--;
else
(void) _putchar(c);
return (OK);
}
int
{
int i, j, k;
/*
* directly with local motions to the right spot.
*/
if (HO) {
/*
* get to the proper column. This assumes ND space costs
* 1 char. So i+destcol is cost of motion with home.
*/
if (GT)
else
i = destcol;
/*
* j is cost to move locally without homing
*/
if (GT && j)
else
}
else
/* leftward motion only works if we can backspace. */
/* cheaper to backspace */
else
j = i + 1; /* impossibly expensive */
/* k is the absolute value of vertical distance */
if (k < 0)
k = -k;
j += k;
/*
* Decision. We may not have a choice if no UP.
*/
/*
* Cheaper to home. Do it now and pretend it's a
* regular local motion.
*/
} else if (LL) {
/*
* Quickly consider homing down and moving from there.
* Assume cost of LL is 2.
*/
if (i + k + 2 < j && (k <= 0 || UP)) {
outcol = 0;
}
}
}
else
/*
* No home and no up means it's impossible.
*/
return (-1);
if (GT)
else
i = destcol;
/*
* if (BT && outcol > destcol &&
* (j = (((outcol+7) & ~7) - destcol - 1) >> 3)) {
* j *= (k = (int)strlen(BT));
* if ((k += (destcol&7)) > 4)
* j += 8 - (destcol&7);
* else
* j += k;
* }
* else
*/
/*
* If we will later need a \n which will turn into a \r\n by
* the system or the terminal, then don't bother to try to \r.
*/
goto dontcr;
/*
* If the terminal will do a \r\n and there isn't room for it,
* then we can't afford a \r.
*/
goto dontcr;
/*
* If it will be cheaper, or if we can't back up, then send
* a return preliminarily.
*/
/*
* BUG: this doesn't take the (possibly long) length
* of CR into account.
*/
if (CR)
else
(void) plodput('\r');
if (NC) {
if (NL)
else
(void) plodput('\n');
outline++;
}
outcol = 0;
}
outline++;
if (NL)
else
(void) plodput('\n');
if (plodcnt < 0)
goto out;
outcol = 0;
}
if (BT)
if (plodcnt < 0)
goto out;
/*
* if (BT && outcol - destcol > k + 4) {
* (void) tputs(BT, 0, plodput);
* outcol--;
* outcol &= ~7;
* continue;
* }
*/
outcol--;
if (BC)
else
(void) plodput('\b');
}
outline--;
if (plodcnt < 0)
goto out;
}
for (;;) {
if (i > destcol)
break;
if (TA)
else
(void) plodput('\t');
outcol = i;
}
if (TA)
else
(void) plodput('\t');
outcol = i;
outcol--;
if (BC)
else
(void) plodput('\b');
}
}
}
/*
* move one char to the right. We don't use ND space
* because it's better to just print the char we are
* moving over.
*/
if (plodflg) /* avoid a complex calculation */
plodcnt--;
else {
(void) _putchar(i & 0177);
else
goto nondes;
}
else
if (ND)
else
(void) plodput(' ');
outcol++;
if (plodcnt < 0)
goto out;
}
out:
if (plodflg) {
}
return (plodcnt);
}
/*
* Return the column number that results from being in column col and
* hitting a tab, where tabs are set every ts columns. Work right for
* the case where col > COLS, even if ts does not divide COLS.
*/
int
{
int offset;
}
else
offset = 0;
}