SCOPE2 int
parse_word(int adrp, int up)
{
int bufend = V(TICK_SOURCE) + V(NUM_SOURCE);
int nextc = V(TICK_SOURCE) + V(TO_IN);
int wordstart = nextc;
int c;
do {
if (nextc >= bufend) {
V(TO_IN) = nextc - V(TICK_SOURCE);
DATA(adrp) = wordstart;
return(0);
}
c = CHARS(nextc++);
} while (c <= ' ');
// Now c contains a non-delimiter character.
wordstart = nextc-1;
DATA(adrp) = wordstart;
do {
if (nextc >= bufend) {
V(TO_IN) = nextc - V(TICK_SOURCE);
return(nextc - wordstart);
}
c = CHARS(nextc++);
} while (c > ' ');
V(TO_IN) = nextc - V(TICK_SOURCE);
return (nextc - wordstart - 1);
}
SCOPE2 int
search_wid(int adr, int len, int wid, int up)
{
// The first character in the string is the Forth count field.
int str, ptr;
int length;
int dictp;
for ( dictp = TOKEN(up + DATA(voc_unum + wid));
dictp != 0;
dictp = TOKEN(to_link(dictp))
) {
length = name_len(dictp);
if (len != length) {
continue;
}
str = to_name_adr(dictp);
ptr = adr;
for ( ; length != 0; --length ) {
if ( CHARS(str++) != CHARS(ptr++) )
break;
}
if (length == 0)
return dictp;
}
return (0); // Not found
}
int
caccept(int addr, cell count, int up)
{
int c;
int p;
if (isinteractive()) {
linemode();
}
// Uses the operating system's terminal driver to do the line editing
for (p = addr; count > 0; count--) {
c = nextchar();
if (c == '\n' || c == EOF) {
break;
}
CHARS(p++) = c;
}
if (isinteractive()) {
// We must do this because the terminal driver does the echoing,
// and the 'return' that ends the line puts the cursor at column 0
V(NUM_OUT) = 0;
}
return ((cell)(p - addr));
}
SCOPE2 void
makeimmediate(int up)
{
// The flag bit is in the length byte, which precedes the xt address
// and the link field
CHARS(to_name_len(LAST)) |= IMMEDBIT;
}
void dfs_component(NODE* nodes, BYTE x, BYTE y, BYTE z, BYTE c) {
INT p = pos(x,y,z);
if (nodes[p].component > 0)
return;
if (nodes[p].component < 0) {
fprintf(stderr, "dfs_component: %c%c%c %d %d", CHARS(x,y,z), nodes[p].component, c);
return;
}
if (out) printf("%c%c%c ", CHARS(x,y,z));
NODE n;
nodes[p].component = c;
BYTE i;
n = nodes[p]; for (i = n.next[0]; i != -1; n = nodes[pos(i,y,z)],i = n.next[0]) dfs_component(nodes, i,y,z,c);
n = nodes[p]; for (i = n.prev[0]; i != -1; n = nodes[pos(i,y,z)],i = n.prev[0]) dfs_component(nodes, i,y,z,c);
n = nodes[p]; for (i = n.next[1]; i != -1; n = nodes[pos(x,i,z)],i = n.next[1]) dfs_component(nodes, x,i,z,c);
n = nodes[p]; for (i = n.prev[1]; i != -1; n = nodes[pos(x,i,z)],i = n.prev[1]) dfs_component(nodes, x,i,z,c);
n = nodes[p]; for (i = n.next[2]; i != -1; n = nodes[pos(x,y,i)],i = n.next[2]) dfs_component(nodes, x,y,i,c);
n = nodes[p]; for (i = n.prev[2]; i != -1; n = nodes[pos(x,y,i)],i = n.prev[2]) dfs_component(nodes, x,y,i,c);
}
SCOPE2 int
alcanonical(int adr, int len, int up)
{
int p, q;
int c;
if (V(CAPS) == 0)
return adr;
q = V(CANONSTR);
if (len > 32)
len = 32;
for (p = adr; (len--) != 0; p++) {
c = CHARS(p);
CHARS(q++) = (c >= 'A' && c <= 'Z') ? (c - 'A' + 'a') : c;
}
return V(CANONSTR);
}
SCOPE2 void
place_name(int adr, int len, int previous, int up)
{
int i;
int rdp;
rdp = V(DP);
// Place the string, then the length byte
for (i = 0; i < len; i++) {
TOKEN(rdp++) = CHARS(adr++);
}
TOKEN(rdp++) = len;
V(DP) = rdp;
linkcomma(previous);
tokstore(V(DP), up + LASTP);
}
cell
freadline(cell f, int sp, int up) // Returns IO result
{
// Stack: adr len -- actual more?
int adr = DS(sp+1);
cell len = DS(sp);
cell actual;
int c;
DS(sp) = -1; // Assume not end of file
for (actual = 0; actual < len; ) {
if ((c = getc((FILE *)f)) == EOF) {
if (actual == 0)
DS(sp) = 0;
if (ferror((FILE *)f)) {
DS(sp+1) = actual;
return(-12);
}
break;
}
if (c == CNEWLINE) { // Last character of an end-of-line sequence
break;
}
// Don't store the first half of a 2-character newline sequence
if (c == SNEWLINE[0])
continue;
CHARS(adr++) = c;
// printf("%c", c);
++actual;
}
// printf("\n");
DS(sp+1) = actual;
return(0);
}
int findComponents(NODE* nodes, BOOL output) {
BYTE x,y,z;
INT c,p;
out = output;
c = 1;
for (z = 0; z < LEN; z++) {
for (y = 0; y < LEN; y++) {
for (x = 0; x < LEN; x++) {
p = pos(x,y,z);
if (nodes[p].component != 0)
continue;
if (out) printf("Component #%d:\n", c, CHARS(x,y,z));
dfs_component(nodes, x,y,z,c);
if (out) printf("\n\n");
c++;
}
}
}
return c - 1;
}
SCOPE2 int
parse(int delim, int sp, int up)
{
int bufend = V(TICK_SOURCE) + V(NUM_SOURCE);
int nextc = V(TICK_SOURCE) + V(TO_IN);
int wordstart = nextc;
int c;
DS(sp) = wordstart;
do {
if (nextc >= bufend) {
V(TO_IN) = nextc - V(TICK_SOURCE);
return(nextc - wordstart);
}
c = CHARS(nextc++);
} while ( c != delim
&& (c > ' ' || delim != ' ' || isinteractive() != 0 )
);
V(TO_IN) = nextc - V(TICK_SOURCE);
return (nextc - wordstart - 1);
}
#include "translate.h"
static const t_unicode cp437_c1_chars[] = {
0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0, 0x00e5, 0x00e7, /* 0x80-0x87 */
0x00ea, 0x00eb, 0x00e8, 0x00ef, 0x00ee, 0x00ec, 0x00c4, 0x00c5, /* 0x88-0x8F */
0x00c9, 0x00e6, 0x00c6, 0x00f4, 0x00f6, 0x00f2, 0x00fb, 0x00f9, /* 0x90-0x97 */
0x00ff, 0x00d6, 0x00dc, 0x00a2, 0x00a3, 0x00a5, 0x20a7, 0x0192, /* 0x98-0x9F */
};
struct char_set cp437_c1 = {
1,
CHARS(cp437_c1_chars),
0, "", 0, 32,
};
static const t_unicode cp437_g1_chars[] = {
0x00e1, 0x00ed, 0x00f3, 0x00fa, 0x00f1, 0x00d1, 0x00aa, 0x00ba, /* 0xA0-0xA7 */
0x00bf, 0x2310, 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00bb, /* 0xA8-0xAF */
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, /* 0xB0-0xB7 */
0x2555, 0x2563, 0x2551, 0x2557, 0x255d, 0x255c, 0x255b, 0x2510, /* 0xB8-0xBF */
0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f, /* 0xC0-0xC7 */
0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x2567, /* 0xC8-0xCF */
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256b, /* 0xD0-0xD7 */
0x256a, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580, /* 0xD8-0xDF */
0x03b1, 0x00df, 0x0393, 0x03c0, 0x03a3, 0x03c3, 0x00b5, 0x03c4, /* 0xE0-0xE7 */
0x03a6, 0x0398, 0x03a9, 0x03b4, 0x221e, 0x03c6, 0x03b5, 0x2229, /* 0xE8-0xEF */
0x2261, 0x00b1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00f7, 0x2248, /* 0xF0-0xF7 */
0x00b0, 0x2219, 0x00b7, 0x221a, 0x207f, 0x00b2, 0x25a0, 0x00a0, /* 0xF8-0xFF */
};
struct char_set cp437_g1 = {
1,
CHARS(cp437_g1_chars),
SCOPE2 int
isimmediate(int xt)
{
return (CHARS(to_name_len(xt)) & IMMEDBIT) != 0 ? 1 : -1;
}
0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x066a, 0x0026, 0x0027, /* 0x20-0x27 */
0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F, /* 0x28-0x2F */
0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, /* 0x30-0x37 */
0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F, /* 0x38-0x3F */
0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, /* 0x40-0x47 */
0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, /* 0x48-0x4F */
0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, /* 0x50-0x57 */
0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F, /* 0x58-0x5F */
0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, /* 0x60-0x67 */
0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, /* 0x68-0x6F */
0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, /* 0x70-0x77 */
0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F, /* 0x78-0x7F */
};
struct char_set cp864_g0 = {
1,
CHARS(cp864_g0_chars),
0, "", 0, 96,
};
static const t_unicode cp864_c1_chars[] = {
0x00b0, 0x00b7, 0x2219, 0x221a, 0x2592, 0x2500, 0x2502, 0x253c, /* 0x80-0x87 */
0x2524, 0x252c, 0x251c, 0x2534, 0x2510, 0x250c, 0x2514, 0x2518, /* 0x88-0x8F */
0x03b2, 0x221e, 0x03c6, 0x00b1, 0x00bd, 0x00bc, 0x2248, 0x00ab, /* 0x90-0x97 */
0x00bb, 0xfef7, 0xfef8, 0xfffd, 0xfffd, 0xfefb, 0xfefc, 0xfffd, /* 0x98-0x9F */
};
struct char_set cp864_c1 = {
1,
CHARS(cp864_c1_chars),
0, "", 0, 32,
};
int tty_ioctl(int dev, int cmd, int arg)
{
struct tty_struct * tty;
if (MAJOR(dev) == 5) {
dev=current->tty;
if (dev<0)
panic("tty_ioctl: dev<0");
} else
dev=MINOR(dev);
tty = dev + tty_table;
switch (cmd) {
case TCGETS:
return get_termios(tty,(struct termios *) arg);
case TCSETSF:
flush(&tty->read_q); /* fallthrough */
case TCSETSW:
wait_until_sent(tty); /* fallthrough */
case TCSETS:
return set_termios(tty,(struct termios *) arg);
case TCGETA:
return get_termio(tty,(struct termio *) arg);
case TCSETAF:
flush(&tty->read_q); /* fallthrough */
case TCSETAW:
wait_until_sent(tty); /* fallthrough */
case TCSETA:
return set_termio(tty,(struct termio *) arg);
case TCSBRK:
if (!arg) {
wait_until_sent(tty);
send_break(tty);
}
return 0;
case TCXONC:
return -EINVAL; /* not implemented */
case TCFLSH:
if (arg==0)
flush(&tty->read_q);
else if (arg==1)
flush(&tty->write_q);
else if (arg==2) {
flush(&tty->read_q);
flush(&tty->write_q);
} else
return -EINVAL;
return 0;
case TIOCEXCL:
return -EINVAL; /* not implemented */
case TIOCNXCL:
return -EINVAL; /* not implemented */
case TIOCSCTTY:
return -EINVAL; /* set controlling term NI */
case TIOCGPGRP:
verify_area((void *) arg,4);
put_fs_long(tty->pgrp,(unsigned long *) arg);
return 0;
case TIOCSPGRP:
tty->pgrp=get_fs_long((unsigned long *) arg);
return 0;
case TIOCOUTQ:
verify_area((void *) arg,4);
put_fs_long(CHARS(tty->write_q),(unsigned long *) arg);
return 0;
case TIOCSTI:
return -EINVAL; /* not implemented */
case TIOCGWINSZ:
return -EINVAL; /* not implemented */
case TIOCSWINSZ:
return -EINVAL; /* not implemented */
case TIOCMGET:
return -EINVAL; /* not implemented */
case TIOCMBIS:
return -EINVAL; /* not implemented */
case TIOCMBIC:
return -EINVAL; /* not implemented */
case TIOCMSET:
return -EINVAL; /* not implemented */
case TIOCGSOFTCAR:
return -EINVAL; /* not implemented */
case TIOCSSOFTCAR:
return -EINVAL; /* not implemented */
default:
return -EINVAL;
}
}
int tty_ioctl(struct inode * inode, struct file * file,
unsigned int cmd, unsigned long arg)
{
struct tty_struct * tty;
struct tty_struct * other_tty;
struct tty_struct * termios_tty;
pid_t pgrp;
int dev;
int termios_dev;
int retval;
if (MAJOR(file->f_rdev) != TTY_MAJOR) {
printk("tty_ioctl: tty pseudo-major != TTY_MAJOR\n");
return -EINVAL;
}
dev = MINOR(file->f_rdev);
tty = TTY_TABLE(dev);
if (!tty)
return -EINVAL;
if (IS_A_PTY(dev))
other_tty = tty_table[PTY_OTHER(dev)];
else
other_tty = NULL;
if (IS_A_PTY_MASTER(dev)) {
termios_tty = other_tty;
termios_dev = PTY_OTHER(dev);
} else {
termios_tty = tty;
termios_dev = dev;
}
switch (cmd) {
case TCGETS:
retval = verify_area(VERIFY_WRITE, (void *) arg,
sizeof (struct termios));
if (retval)
return retval;
memcpy_tofs((struct termios *) arg,
termios_tty->termios,
sizeof (struct termios));
return 0;
case TCSETSF:
case TCSETSW:
case TCSETS:
retval = check_change(termios_tty, termios_dev);
if (retval)
return retval;
if (cmd == TCSETSF || cmd == TCSETSW) {
if (cmd == TCSETSF)
flush_input(termios_tty);
wait_until_sent(termios_tty, 0);
}
return set_termios(termios_tty, (struct termios *) arg,
termios_dev);
case TCGETA:
return get_termio(termios_tty,(struct termio *) arg);
case TCSETAF:
case TCSETAW:
case TCSETA:
retval = check_change(termios_tty, termios_dev);
if (retval)
return retval;
if (cmd == TCSETAF || cmd == TCSETAW) {
if (cmd == TCSETAF)
flush_input(termios_tty);
wait_until_sent(termios_tty, 0);
}
return set_termio(termios_tty, (struct termio *) arg,
termios_dev);
case TCXONC:
retval = check_change(tty, dev);
if (retval)
return retval;
switch (arg) {
case TCOOFF:
stop_tty(tty);
break;
case TCOON:
start_tty(tty);
break;
case TCIOFF:
if (STOP_CHAR(tty) != __DISABLED_CHAR)
put_tty_queue(STOP_CHAR(tty),
&tty->write_q);
break;
case TCION:
if (START_CHAR(tty) != __DISABLED_CHAR)
put_tty_queue(START_CHAR(tty),
&tty->write_q);
break;
default:
return -EINVAL;
}
return 0;
case TCFLSH:
retval = check_change(tty, dev);
if (retval)
return retval;
switch (arg) {
case TCIFLUSH:
flush_input(tty);
break;
case TCIOFLUSH:
flush_input(tty);
/* fall through */
case TCOFLUSH:
flush_output(tty);
break;
default:
return -EINVAL;
}
return 0;
case TIOCEXCL:
set_bit(TTY_EXCLUSIVE, &tty->flags);
return 0;
case TIOCNXCL:
clear_bit(TTY_EXCLUSIVE, &tty->flags);
return 0;
case TIOCSCTTY:
if (current->leader &&
(current->session == tty->session))
return 0;
/*
* The process must be a session leader and
* not have a controlling tty already.
*/
if (!current->leader || (current->tty >= 0))
return -EPERM;
if (tty->session > 0) {
/*
* This tty is already the controlling
* tty for another session group!
*/
if ((arg == 1) && suser()) {
/*
* Steal it away
*/
struct task_struct *p;
for_each_task(p)
if (p->tty == dev)
p->tty = -1;
} else
return -EPERM;
}
current->tty = dev;
tty->session = current->session;
tty->pgrp = current->pgrp;
return 0;
case TIOCGPGRP:
retval = verify_area(VERIFY_WRITE, (void *) arg,
sizeof (pid_t));
if (retval)
return retval;
if (current->tty != termios_dev)
return -ENOTTY;
put_fs_long(termios_tty->pgrp, (pid_t *) arg);
return 0;
case TIOCSPGRP:
retval = check_change(termios_tty, termios_dev);
if (retval)
return retval;
if ((current->tty < 0) ||
(current->tty != termios_dev) ||
(termios_tty->session != current->session))
return -ENOTTY;
pgrp = get_fs_long((pid_t *) arg);
if (pgrp < 0)
return -EINVAL;
if (session_of_pgrp(pgrp) != current->session)
return -EPERM;
termios_tty->pgrp = pgrp;
return 0;
case TIOCOUTQ:
retval = verify_area(VERIFY_WRITE, (void *) arg,
sizeof (unsigned long));
if (retval)
return retval;
put_fs_long(CHARS(&tty->write_q),
(unsigned long *) arg);
return 0;
case TIOCINQ:
retval = verify_area(VERIFY_WRITE, (void *) arg,
sizeof (unsigned long));
if (retval)
return retval;
if (L_ICANON(tty))
put_fs_long(inq_canon(tty),
(unsigned long *) arg);
else
put_fs_long(CHARS(&tty->secondary),
(unsigned long *) arg);
return 0;
case TIOCSTI:
if ((current->tty != dev) && !suser())
return -EPERM;
retval = verify_area(VERIFY_READ, (void *) arg, 1);
if (retval)
return retval;
put_tty_queue(get_fs_byte((char *) arg), &tty->read_q);
TTY_READ_FLUSH(tty);
return 0;
case TIOCGWINSZ:
retval = verify_area(VERIFY_WRITE, (void *) arg,
sizeof (struct winsize));
if (retval)
return retval;
memcpy_tofs((struct winsize *) arg, &tty->winsize,
sizeof (struct winsize));
return 0;
case TIOCSWINSZ:
if (IS_A_PTY_MASTER(dev))
set_window_size(other_tty,(struct winsize *) arg);
return set_window_size(tty,(struct winsize *) arg);
case TIOCLINUX:
switch (get_fs_byte((char *)arg))
{
case 0:
return do_screendump(arg);
case 1:
return do_get_ps_info(arg);
#ifdef CONFIG_SELECTION
case 2:
return set_selection(arg);
case 3:
return paste_selection(tty);
case 4:
unblank_screen();
return 0;
#endif /* CONFIG_SELECTION */
default:
return -EINVAL;
}
case TIOCCONS:
if (IS_A_CONSOLE(dev)) {
if (!suser())
return -EPERM;
redirect = NULL;
return 0;
}
if (redirect)
return -EBUSY;
if (!suser())
return -EPERM;
if (IS_A_PTY_MASTER(dev))
redirect = other_tty;
else if (IS_A_PTY_SLAVE(dev))
redirect = tty;
else
return -ENOTTY;
return 0;
case FIONBIO:
arg = get_fs_long((unsigned long *) arg);
if (arg)
file->f_flags |= O_NONBLOCK;
else
file->f_flags &= ~O_NONBLOCK;
return 0;
case TIOCNOTTY:
if (current->tty != dev)
return -ENOTTY;
if (current->leader)
disassociate_ctty(0);
current->tty = -1;
return 0;
case TIOCGETD:
retval = verify_area(VERIFY_WRITE, (void *) arg,
sizeof (unsigned long));
if (retval)
return retval;
put_fs_long(tty->disc, (unsigned long *) arg);
return 0;
case TIOCSETD:
retval = check_change(tty, dev);
if (retval)
return retval;
arg = get_fs_long((unsigned long *) arg);
return tty_set_ldisc(tty, arg);
case TIOCGLCKTRMIOS:
arg = get_fs_long((unsigned long *) arg);
retval = verify_area(VERIFY_WRITE, (void *) arg,
sizeof (struct termios));
if (retval)
return retval;
memcpy_tofs((struct termios *) arg,
&termios_locked[termios_dev],
sizeof (struct termios));
return 0;
case TIOCSLCKTRMIOS:
if (!suser())
return -EPERM;
arg = get_fs_long((unsigned long *) arg);
memcpy_fromfs(&termios_locked[termios_dev],
(struct termios *) arg,
sizeof (struct termios));
return 0;
case TIOCPKT:
if (!IS_A_PTY_MASTER(dev))
return -ENOTTY;
retval = verify_area(VERIFY_READ, (void *) arg,
sizeof (unsigned long));
if (retval)
return retval;
if (get_fs_long(arg)) {
if (!tty->packet) {
tty->packet = 1;
tty->link->ctrl_status = 0;
}
} else
tty->packet = 0;
return 0;
case TCSBRK: case TCSBRKP:
retval = check_change(tty, dev);
if (retval)
return retval;
wait_until_sent(tty, 0);
if (!tty->ioctl)
return 0;
tty->ioctl(tty, file, cmd, arg);
return 0;
default:
if (tty->ioctl) {
retval = (tty->ioctl)(tty, file, cmd, arg);
if (retval != -EINVAL)
return retval;
}
if (ldiscs[tty->disc].ioctl) {
retval = (ldiscs[tty->disc].ioctl)
(tty, file, cmd, arg);
return retval;
}
return -EINVAL;
}
#include "translate.h"
static const t_unicode cp857_c1_chars[] = {
0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0, 0x00e5, 0x00e7, /* 0x80-0x87 */
0x00ea, 0x00eb, 0x00e8, 0x00ef, 0x00ee, 0x0131, 0x00c4, 0x00c5, /* 0x88-0x8F */
0x00c9, 0x00e6, 0x00c6, 0x00f4, 0x00f6, 0x00f2, 0x00fb, 0x00f9, /* 0x90-0x97 */
0x0130, 0x00d6, 0x00dc, 0x00f8, 0x00a3, 0x00d8, 0x015e, 0x015f, /* 0x98-0x9F */
};
struct char_set cp857_c1 = {
1,
CHARS(cp857_c1_chars),
0, "", 0, 32,
};
static const t_unicode cp857_g1_chars[] = {
0x00e1, 0x00ed, 0x00f3, 0x00fa, 0x00f1, 0x00d1, 0x011e, 0x011f, /* 0xA0-0xA7 */
0x00bf, 0x00ae, 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00bb, /* 0xA8-0xAF */
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00c1, 0x00c2, 0x00c0, /* 0xB0-0xB7 */
0x00a9, 0x2563, 0x2551, 0x2557, 0x255d, 0x00a2, 0x00a5, 0x2510, /* 0xB8-0xBF */
0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x00e3, 0x00c3, /* 0xC0-0xC7 */
0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x00a4, /* 0xC8-0xCF */
0x00ba, 0x00aa, 0x00ca, 0x00cb, 0x00c8, 0xfffd, 0x00cd, 0x00ce, /* 0xD0-0xD7 */
0x00cf, 0x2518, 0x250c, 0x2588, 0x2584, 0x00a6, 0x00cc, 0x2580, /* 0xD8-0xDF */
0x00d3, 0x00df, 0x00d4, 0x00d2, 0x00f5, 0x00d5, 0x00b5, 0xfffd, /* 0xE0-0xE7 */
0x00d7, 0x00da, 0x00db, 0x00d9, 0x00ec, 0x00ff, 0x00af, 0x00b4, /* 0xE8-0xEF */
0x00ad, 0x00b1, 0xfffd, 0x00be, 0x00b6, 0x00a7, 0x00f7, 0x00b8, /* 0xF0-0xF7 */
0x00b0, 0x00a8, 0x00b7, 0x00b9, 0x00b3, 0x00b2, 0x25a0, 0x00a0, /* 0xF8-0xFF */
};
struct char_set cp857_g1 = {
1,
CHARS(cp857_g1_chars),
#include "translate.h"
static const t_unicode cp775_c1_chars[] = {
0x0106, 0x00fc, 0x00e9, 0x0101, 0x00e4, 0x0123, 0x00e5, 0x0107, /* 0x80-0x87 */
0x0142, 0x0113, 0x0156, 0x0157, 0x012b, 0x0179, 0x00c4, 0x00c5, /* 0x88-0x8F */
0x00c9, 0x00e6, 0x00c6, 0x014d, 0x00f6, 0x0122, 0x00a2, 0x015a, /* 0x90-0x97 */
0x015b, 0x00d6, 0x00dc, 0x00f8, 0x00a3, 0x00d8, 0x00d7, 0x00a4, /* 0x98-0x9F */
};
struct char_set cp775_c1 = {
1,
CHARS(cp775_c1_chars),
0, "", 0, 32,
};
static const t_unicode cp775_g1_chars[] = {
0x0100, 0x012a, 0x00f3, 0x017b, 0x017c, 0x017a, 0x201d, 0x00a6, /* 0xA0-0xA7 */
0x00a9, 0x00ae, 0x00ac, 0x00bd, 0x00bc, 0x0141, 0x00ab, 0x00bb, /* 0xA8-0xAF */
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x0104, 0x010c, 0x0118, /* 0xB0-0xB7 */
0x0116, 0x2563, 0x2551, 0x2557, 0x255d, 0x012e, 0x0160, 0x2510, /* 0xB8-0xBF */
0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x0172, 0x016a, /* 0xC0-0xC7 */
0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x017d, /* 0xC8-0xCF */
0x0105, 0x010d, 0x0119, 0x0117, 0x012f, 0x0161, 0x0173, 0x016b, /* 0xD0-0xD7 */
0x017e, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580, /* 0xD8-0xDF */
0x00d3, 0x00df, 0x014c, 0x0143, 0x00f5, 0x00d5, 0x00b5, 0x0144, /* 0xE0-0xE7 */
0x0136, 0x0137, 0x013b, 0x013c, 0x0146, 0x0112, 0x0145, 0x2019, /* 0xE8-0xEF */
0x00ad, 0x00b1, 0x201c, 0x00be, 0x00b6, 0x00a7, 0x00f7, 0x201e, /* 0xF0-0xF7 */
0x00b0, 0x2219, 0x00b7, 0x00b9, 0x00b3, 0x00b2, 0x25a0, 0x00a0, /* 0xF8-0xFF */
};
struct char_set cp775_g1 = {
1,
CHARS(cp775_g1_chars),
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x20AC, 0x00A5, 0x0160, 0x00A7, /* 0xA0-0xA7 */
0x0161, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF, /* 0xA8-0xAF */
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x017D, 0x00B5, 0x00B6, 0x00B7, /* 0xB0-0xB7 */
0x017E, 0x00B9, 0x00BA, 0x00BB, 0x0152, 0x0153, 0x0178, 0x00BF, /* 0xB8-0xBF */
0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7, /* 0xC0-0xC7 */
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF, /* 0xC8-0xCF */
0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7, /* 0xD0-0xD7 */
0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF, /* 0xD8-0xDF */
0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, /* 0xE0-0xE7 */
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF, /* 0xE8-0xEF */
0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7, /* 0xF0-0xF7 */
0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF, /* 0xF8-0xFF */
};
struct char_set iso8859_15_g1 = {
1,
CHARS(iso8859_15_g1_chars),
0, "", 1, 96,
};
struct char_set iso8859_15 = {
.c0 = &ascii_c0,
.g0 = &ascii_g0,
.c1 = &ascii_c1,
.g1 = &iso8859_15_g1,
.names = { "iso8859_15", 0 },
};
CONSTRUCTOR(static void init(void))
{
register_charset(&iso8859_15_g1);
register_charset(&iso8859_15);
#include "translate.h"
static const t_unicode cp863_c1_chars[] = {
0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00c2, 0x00e0, 0x00b6, 0x00e7, /* 0x80-0x87 */
0x00ea, 0x00eb, 0x00e8, 0x00ef, 0x00ee, 0x2017, 0x00c0, 0x00a7, /* 0x88-0x8F */
0x00c9, 0x00c8, 0x00ca, 0x00f4, 0x00cb, 0x00cf, 0x00fb, 0x00f9, /* 0x90-0x97 */
0x00a4, 0x00d4, 0x00dc, 0x00a2, 0x00a3, 0x00d9, 0x00db, 0x0192, /* 0x98-0x9F */
};
struct char_set cp863_c1 = {
1,
CHARS(cp863_c1_chars),
0, "", 0, 32,
};
static const t_unicode cp863_g1_chars[] = {
0x00a6, 0x00b4, 0x00f3, 0x00fa, 0x00a8, 0x00b8, 0x00b3, 0x00af, /* 0xA0-0xA7 */
0x00ce, 0x2310, 0x00ac, 0x00bd, 0x00bc, 0x00be, 0x00ab, 0x00bb, /* 0xA8-0xAF */
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, /* 0xB0-0xB7 */
0x2555, 0x2563, 0x2551, 0x2557, 0x255d, 0x255c, 0x255b, 0x2510, /* 0xB8-0xBF */
0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f, /* 0xC0-0xC7 */
0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x2567, /* 0xC8-0xCF */
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256b, /* 0xD0-0xD7 */
0x256a, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580, /* 0xD8-0xDF */
0x03b1, 0x00df, 0x0393, 0x03c0, 0x03a3, 0x03c3, 0x00b5, 0x03c4, /* 0xE0-0xE7 */
0x03a6, 0x0398, 0x03a9, 0x03b4, 0x221e, 0x03c6, 0x03b5, 0x2229, /* 0xE8-0xEF */
0x2261, 0x00b1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00f7, 0x2248, /* 0xF0-0xF7 */
0x00b0, 0x2219, 0x00b7, 0x221a, 0x207f, 0x00b2, 0x25a0, 0x00a0, /* 0xF8-0xFF */
};
struct char_set cp863_g1 = {
1,
CHARS(cp863_g1_chars),
0x00A0, 0x0104, 0x0112, 0x0122, 0x012A, 0x0128, 0x0136, 0x00A7, /* 0xA0-0xA7 */
0x013B, 0x0110, 0x0160, 0x0166, 0x017D, 0x00AD, 0x016A, 0x014A, /* 0xA8-0xAF */
0x00B0, 0x0105, 0x0113, 0x0123, 0x012B, 0x0129, 0x0137, 0x00B7, /* 0xB0-0xB7 */
0x013C, 0x0111, 0x0161, 0x0167, 0x017E, 0x2015, 0x016B, 0x014B, /* 0xB8-0xBF */
0x0100, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x012E, /* 0xC0-0xC7 */
0x010C, 0x00C9, 0x0118, 0x00CB, 0x0116, 0x00CD, 0x00CE, 0x00CF, /* 0xC8-0xCF */
0x00D0, 0x0145, 0x014C, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x0168, /* 0xD0-0xD7 */
0x00D8, 0x0172, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF, /* 0xD8-0xDF */
0x0101, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x012F, /* 0xE0-0xE7 */
0x010D, 0x00E9, 0x0119, 0x00EB, 0x0117, 0x00ED, 0x00EE, 0x00EF, /* 0xE8-0xEF */
0x00F0, 0x0146, 0x014D, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x0169, /* 0xF0-0xF7 */
0x00F8, 0x0173, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x0138, /* 0xF8-0xFF */
};
struct char_set iso8859_10_g1 = {
1,
CHARS(iso8859_10_g1_chars),
157, "V", 1, 96,
};
struct char_set iso8859_10 = {
.c0 = &ascii_c0,
.g0 = &ascii_g0,
.c1 = &ascii_c1,
.g1 = &iso8859_10_g1,
.names = { "iso8859-10", 0 },
};
CONSTRUCTOR(static void init(void))
{
register_charset(&iso8859_10_g1);
register_charset(&iso8859_10);
#include "translate.h"
static const t_unicode koi8_r_c1_chars[] = {
0x2500, 0x2502, 0x250C, 0x2510, 0x2514, 0x2518, 0x251C, 0x2524, /* 0x80-0x87 */
0x252C, 0x2534, 0x253C, 0x2580, 0x2584, 0x2588, 0x258C, 0x2590, /* 0x88-0x8F */
0x2591, 0x2592, 0x2593, 0x2320, 0x25A0, 0x2219, 0x221A, 0x2248, /* 0x90-0x97 */
0x2264, 0x2265, 0x00A0, 0x2321, 0x00B0, 0x00B2, 0x00B7, 0x00F7, /* 0x98-0x9F */
};
struct char_set koi8_r_c1 = {
1,
CHARS(koi8_r_c1_chars),
0, "", 0, 32,
};
static const t_unicode koi8_r_g1_chars[] = {
0x2550, 0x2551, 0x2552, 0x0451, 0x2553, 0x2554, 0x2555, 0x2556, /* 0xA0-0xA7 */
0x2557, 0x2558, 0x2559, 0x255A, 0x255B, 0x255C, 0x255D, 0x255E, /* 0xA8-0xAF */
0x255F, 0x2560, 0x2561, 0x0401, 0x2562, 0x2563, 0x2564, 0x2565, /* 0xB0-0xB7 */
0x2566, 0x2567, 0x2568, 0x2569, 0x256A, 0x256B, 0x256C, 0x00A9, /* 0xB8-0xBF */
0x044E, 0x0430, 0x0431, 0x0446, 0x0434, 0x0435, 0x0444, 0x0433, /* 0xC0-0xC7 */
0x0445, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, /* 0xC8-0xCF */
0x043F, 0x044F, 0x0440, 0x0441, 0x0442, 0x0443, 0x0436, 0x0432, /* 0xD0-0xD7 */
0x044C, 0x044B, 0x0437, 0x0448, 0x044D, 0x0449, 0x0447, 0x044A, /* 0xD8-0xDF */
0x042E, 0x0410, 0x0411, 0x0426, 0x0414, 0x0415, 0x0424, 0x0413, /* 0xE0-0xE7 */
0x0425, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, /* 0xE8-0xEF */
0x041F, 0x042F, 0x0420, 0x0421, 0x0422, 0x0423, 0x0416, 0x0412, /* 0xF0-0xF7 */
0x042C, 0x042B, 0x0417, 0x0428, 0x042D, 0x0429, 0x0427, 0x042A, /* 0xF8-0xFF */
};
struct char_set koi8_r_g1 = {
1,
#include "translate.h"
static const t_unicode cp855_c1_chars[] = {
0x0452, 0x0402, 0x0453, 0x0403, 0x0451, 0x0401, 0x0454, 0x0404, /* 0x80-0x87 */
0x0455, 0x0405, 0x0456, 0x0406, 0x0457, 0x0407, 0x0458, 0x0408, /* 0x88-0x8F */
0x0459, 0x0409, 0x045a, 0x040a, 0x045b, 0x040b, 0x045c, 0x040c, /* 0x90-0x97 */
0x045e, 0x040e, 0x045f, 0x040f, 0x044e, 0x042e, 0x044a, 0x042a, /* 0x98-0x9F */
};
struct char_set cp855_c1 = {
1,
CHARS(cp855_c1_chars),
0, "", 0, 32,
};
static const t_unicode cp855_g1_chars[] = {
0x0430, 0x0410, 0x0431, 0x0411, 0x0446, 0x0426, 0x0434, 0x0414, /* 0xA0-0xA7 */
0x0435, 0x0415, 0x0444, 0x0424, 0x0433, 0x0413, 0x00ab, 0x00bb, /* 0xA8-0xAF */
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x0445, 0x0425, 0x0438, /* 0xB0-0xB7 */
0x0418, 0x2563, 0x2551, 0x2557, 0x255d, 0x0439, 0x0419, 0x2510, /* 0xB8-0xBF */
0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x043a, 0x041a, /* 0xC0-0xC7 */
0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x00a4, /* 0xC8-0xCF */
0x043b, 0x041b, 0x043c, 0x041c, 0x043d, 0x041d, 0x043e, 0x041e, /* 0xD0-0xD7 */
0x043f, 0x2518, 0x250c, 0x2588, 0x2584, 0x041f, 0x044f, 0x2580, /* 0xD8-0xDF */
0x042f, 0x0440, 0x0420, 0x0441, 0x0421, 0x0442, 0x0422, 0x0443, /* 0xE0-0xE7 */
0x0423, 0x0436, 0x0416, 0x0432, 0x0412, 0x044c, 0x042c, 0x2116, /* 0xE8-0xEF */
0x00ad, 0x044b, 0x042b, 0x0437, 0x0417, 0x0448, 0x0428, 0x044d, /* 0xF0-0xF7 */
0x042d, 0x0449, 0x0429, 0x0447, 0x0427, 0x00a7, 0x25a0, 0x00a0, /* 0xF8-0xFF */
};
struct char_set cp855_g1 = {
1,
CHARS(cp855_g1_chars),
/* FIXME: needs comment: */
void
scm_scmval_print(LONGEST svalue, struct ui_file *stream, int format,
int deref_ref, int recurse, enum val_prettyprint pretty)
{
taloop:
switch (7 & (int)svalue)
{
case 2:
case 6:
print_longest(stream, (format ? format : 'd'), 1, (svalue >> 2));
break;
case 4:
if (SCM_ICHRP(svalue))
{
svalue = SCM_ICHR(svalue);
scm_printchar((int)svalue, stream);
break;
}
else if (SCM_IFLAGP(svalue)
&& ((size_t)SCM_ISYMNUM(svalue)
< (sizeof(scm_isymnames) / sizeof(char *))))
{
fputs_filtered(SCM_ISYMCHARS(svalue), stream);
break;
}
else if (SCM_ILOCP(svalue))
{
fprintf_filtered(stream, "#@%ld%c%ld",
(long)SCM_IFRAME(svalue),
(SCM_ICDRP(svalue) ? '-' : '+'),
(long)SCM_IDIST(svalue));
break;
}
else
goto idef;
break;
case 1:
/* gloc */
svalue = SCM_CAR (svalue - 1);
goto taloop;
default:
idef:
scm_ipruk ("immediate", svalue, stream);
break;
case 0:
switch (SCM_TYP7 (svalue))
{
case scm_tcs_cons_gloc:
if (SCM_CDR (SCM_CAR (svalue) - 1L) == 0)
{
#if 0
SCM name;
#endif /* 0 */
fputs_filtered ("#<latte ", stream);
#if 1
fputs_filtered ("???", stream);
#else
name = ((SCM n *) (STRUCT_TYPE (exp)))[struct_i_name];
scm_lfwrite (CHARS (name),
(sizet) sizeof (char),
(sizet) LENGTH (name),
port);
#endif /* 1 */
fprintf_filtered (stream, " #X%s>", paddr_nz (svalue));
break;
}
/* -Wimplicit-fallthrough vs. -Wdeclaration-after-statement: */
goto imcar_noncase_label;
imcar_noncase_label:
case scm_tcs_cons_imcar:
case scm_tcs_cons_nimcar:
fputs_filtered ("(", stream);
scm_scmlist_print (svalue, stream, format,
deref_ref, recurse + 1, pretty);
fputs_filtered (")", stream);
break;
case scm_tcs_closures:
fputs_filtered ("#<CLOSURE ", stream);
scm_scmlist_print (SCM_CODE (svalue), stream, format,
deref_ref, recurse + 1, pretty);
fputs_filtered (">", stream);
break;
case scm_tc7_string:
{
size_t len = SCM_LENGTH(svalue);
CORE_ADDR addr = (CORE_ADDR)SCM_CDR(svalue);
size_t i;
size_t done = 0UL;
size_t buf_size;
gdb_byte buffer[64];
int truncate = (print_max && (len > print_max));
if (truncate)
len = print_max;
fputs_filtered ("\"", stream);
for (; done < len; done += buf_size)
{
buf_size = min((len - done), 64);
read_memory((addr + done), buffer, (int)buf_size);
for (i = 0; i < buf_size; ++i)
switch (buffer[i])
{
case '\"':
case '\\':
fputs_filtered("\\", stream);
goto the_default_label;
the_default_label:
default:
fprintf_filtered(stream, "%c", buffer[i]);
}
}
fputs_filtered((truncate ? "...\"" : "\""), stream);
break;
}
break;
case scm_tcs_symbols:
{
const size_t len = min(SCM_LENGTH(svalue), MAX_ALLOCA_SIZE);
char *str = (char *)alloca(min(len, MAX_ALLOCA_SIZE));
read_memory(SCM_CDR(svalue), (gdb_byte *)str, (int)(len + 1));
/* Should handle weird characters, FIXME: do it. */
str[len] = '\0';
fputs_filtered(str, stream);
break;
}
case scm_tc7_vector:
{
long len = SCM_LENGTH(svalue);
int i;
LONGEST elements = SCM_CDR(svalue);
fputs_filtered ("#(", stream);
for (i = 0; i < len; ++i)
{
if (i > 0)
fputs_filtered (" ", stream);
scm_scmval_print (scm_get_field (elements, i), stream, format,
deref_ref, recurse + 1, pretty);
}
fputs_filtered (")", stream);
}
break;
#if 0
case tc7_lvector:
{
SCM result;
SCM hook;
hook = scm_get_lvector_hook (exp, LV_PRINT_FN);
if (hook == BOOL_F)
{
scm_puts ("#<locked-vector ", port);
scm_intprint (CDR (exp), 16, port);
scm_puts (">", port);
}
else
{
result
= scm_apply (hook,
scm_listify (exp, port,
(writing ? BOOL_T : BOOL_F),
SCM_UNDEFINED),
EOL);
if (result == BOOL_F)
goto punk;
}
break;
}
break;
case tc7_bvect:
case tc7_ivect:
case tc7_uvect:
case tc7_fvect:
case tc7_dvect:
case tc7_cvect:
scm_raprin1 (exp, port, writing);
break;
#endif /* 0 */
case scm_tcs_subrs:
{
int index = (int)(SCM_CAR(svalue) >> 8);
#if 1
char str[20];
snprintf(str, sizeof(str), "#%d", index);
#else
char *str = (index ? SCM_CHARS(scm_heap_org + index) : "");
# define SCM_CHARS(x) ((char *)(SCM_CDR(x)))
char *str = CHARS(SNAME(exp));
#endif /* 1 */
fprintf_filtered(stream, "#<primitive-procedure %s>",
str);
}
break;
#if 0
#ifdef CCLO
case tc7_cclo:
scm_puts ("#<compiled-closure ", port);
scm_iprin1 (CCLO_SUBR (exp), port, writing);
scm_putc ('>', port);
break;
#endif
case tc7_contin:
fprintf_filtered (stream, "#<continuation %d @ #X%lx >",
LENGTH (svalue),
(long) CHARS (svalue));
break;
case tc7_port:
i = PTOBNUM (exp);
if (i < scm_numptob
&& scm_ptobs[i].print
&& (scm_ptobs[i].print) (exp, port, writing))
break;
goto punk;
case tc7_smob:
i = SMOBNUM (exp);
if (i < scm_numsmob && scm_smobs[i].print
&& (scm_smobs[i].print) (exp, port, writing))
break;
goto punk;
#endif
default:
#if 0
punk:
#endif
scm_ipruk ("type", svalue, stream);
}
break;
}
}
SCOPE2 int
name_from(int nfa)
{
return ( nfa + CHARS(nfa) + 1 );
}
#include "translate.h"
static const t_unicode cp865_c1_chars[] = {
0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0, 0x00e5, 0x00e7, /* 0x80-0x87 */
0x00ea, 0x00eb, 0x00e8, 0x00ef, 0x00ee, 0x00ec, 0x00c4, 0x00c5, /* 0x88-0x8F */
0x00c9, 0x00e6, 0x00c6, 0x00f4, 0x00f6, 0x00f2, 0x00fb, 0x00f9, /* 0x90-0x97 */
0x00ff, 0x00d6, 0x00dc, 0x00f8, 0x00a3, 0x00d8, 0x20a7, 0x0192, /* 0x98-0x9F */
};
struct char_set cp865_c1 = {
1,
CHARS(cp865_c1_chars),
0, "", 0, 32,
};
static const t_unicode cp865_g1_chars[] = {
0x00e1, 0x00ed, 0x00f3, 0x00fa, 0x00f1, 0x00d1, 0x00aa, 0x00ba, /* 0xA0-0xA7 */
0x00bf, 0x2310, 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00a4, /* 0xA8-0xAF */
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, /* 0xB0-0xB7 */
0x2555, 0x2563, 0x2551, 0x2557, 0x255d, 0x255c, 0x255b, 0x2510, /* 0xB8-0xBF */
0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f, /* 0xC0-0xC7 */
0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x2567, /* 0xC8-0xCF */
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256b, /* 0xD0-0xD7 */
0x256a, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580, /* 0xD8-0xDF */
0x03b1, 0x00df, 0x0393, 0x03c0, 0x03a3, 0x03c3, 0x00b5, 0x03c4, /* 0xE0-0xE7 */
0x03a6, 0x0398, 0x03a9, 0x03b4, 0x221e, 0x03c6, 0x03b5, 0x2229, /* 0xE8-0xEF */
0x2261, 0x00b1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00f7, 0x2248, /* 0xF0-0xF7 */
0x00b0, 0x2219, 0x00b7, 0x221a, 0x207f, 0x00b2, 0x25a0, 0x00a0, /* 0xF8-0xFF */
};
struct char_set cp865_g1 = {
1,
CHARS(cp865_g1_chars),
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7, /* 0xA0-0xA7 */
0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF, /* 0xA8-0xAF */
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7, /* 0xB0-0xB7 */
0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF, /* 0xB8-0xBF */
0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7, /* 0xC0-0xC7 */
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF, /* 0xC8-0xCF */
0x011E, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7, /* 0xD0-0xD7 */
0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x0130, 0x015E, 0x00DF, /* 0xD8-0xDF */
0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, /* 0xE0-0xE7 */
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF, /* 0xE8-0xEF */
0x011F, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7, /* 0xF0-0xF7 */
0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0131, 0x015F, 0x00FF, /* 0xF8-0xFF */
};
struct char_set iso8859_9_g1 = {
1,
CHARS(iso8859_9_g1_chars),
148, "M", 1, 96,
};
struct char_set iso8859_9 = {
.c0 = &ascii_c0,
.g0 = &ascii_g0,
.c1 = &ascii_c1,
.g1 = &iso8859_9_g1,
.names = { "iso8859-9", 0 },
};
CONSTRUCTOR(static void init(void))
{
register_charset(&iso8859_9_g1);
register_charset(&iso8859_9);
0x00A0, 0xfffd, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7, /* 0xA0-0xA7 */
0x00A8, 0x00A9, 0x00D7, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x203E, /* 0xA8-0xAF */
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7, /* 0xB0-0xB7 */
0x00B8, 0x00B9, 0x00F7, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0xfffd, /* 0xB8-0xBF */
0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, /* 0xC0-0xC7 */
0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, /* 0xC8-0xCF */
0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, /* 0xD0-0xD7 */
0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0x2017, /* 0xD8-0xDF */
0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7, /* 0xE0-0xE7 */
0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF, /* 0xE8-0xEF */
0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7, /* 0xF0-0xF7 */
0x05E8, 0x05E9, 0x05EA, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, /* 0xF8-0xFF */
};
struct char_set iso8859_8_g1 = {
1,
CHARS(iso8859_8_g1_chars),
138, "H", 1, 96,
};
struct char_set iso8859_8 = {
.c0 = &ascii_c0,
.g0 = &ascii_g0,
.c1 = &ascii_c1,
.g1 = &iso8859_8_g1,
.names = { "iso8859-8", 0 },
};
CONSTRUCTOR(static void init(void))
{
register_charset(&iso8859_8_g1);
register_charset(&iso8859_8);
}
int tty_ioctl(struct inode * inode, struct file * file,
unsigned int cmd, unsigned int arg)
{
struct tty_struct * tty;
struct tty_struct * other_tty;
int pgrp;
int dev;
if (MAJOR(file->f_rdev) != 4) {
printk("tty_ioctl: tty pseudo-major != 4\n");
return -EINVAL;
}
dev = MINOR(file->f_rdev);
tty = TTY_TABLE(dev);
if (!tty)
return -EINVAL;
if (IS_A_PTY(dev))
other_tty = tty_table[PTY_OTHER(dev)];
else
other_tty = NULL;
switch (cmd) {
case TCGETS:
return get_termios(tty,(struct termios *) arg);
case TCSETSF:
flush_input(tty);
/* fallthrough */
case TCSETSW:
wait_until_sent(tty);
/* fallthrough */
case TCSETS:
return set_termios(tty,(struct termios *) arg, dev);
case TCGETA:
return get_termio(tty,(struct termio *) arg);
case TCSETAF:
flush_input(tty);
/* fallthrough */
case TCSETAW:
wait_until_sent(tty); /* fallthrough */
case TCSETA:
return set_termio(tty,(struct termio *) arg, dev);
case TCXONC:
switch (arg) {
case TCOOFF:
tty->stopped = 1;
TTY_WRITE_FLUSH(tty);
return 0;
case TCOON:
tty->stopped = 0;
TTY_WRITE_FLUSH(tty);
return 0;
case TCIOFF:
if (STOP_CHAR(tty))
put_tty_queue(STOP_CHAR(tty),
&tty->write_q);
return 0;
case TCION:
if (START_CHAR(tty))
put_tty_queue(START_CHAR(tty),
&tty->write_q);
return 0;
}
return -EINVAL; /* not implemented */
case TCFLSH:
if (arg==0)
flush_input(tty);
else if (arg==1)
flush_output(tty);
else if (arg==2) {
flush_input(tty);
flush_output(tty);
} else
return -EINVAL;
return 0;
case TIOCEXCL:
return -EINVAL; /* not implemented */
case TIOCNXCL:
return -EINVAL; /* not implemented */
case TIOCSCTTY:
return -EINVAL; /* set controlling term NI */
case TIOCGPGRP:
verify_area((void *) arg,4);
put_fs_long(tty->pgrp,(unsigned long *) arg);
return 0;
case TIOCSPGRP:
if ((current->tty < 0) ||
(current->tty != dev) ||
(tty->session != current->session))
return -ENOTTY;
pgrp=get_fs_long((unsigned long *) arg);
if (pgrp < 0)
return -EINVAL;
if (session_of_pgrp(pgrp) != current->session)
return -EPERM;
tty->pgrp = pgrp;
return 0;
case TIOCOUTQ:
verify_area((void *) arg,4);
put_fs_long(CHARS(&tty->write_q),
(unsigned long *) arg);
return 0;
case TIOCINQ:
verify_area((void *) arg,4);
if (L_CANON(tty) && !tty->secondary.data)
put_fs_long(0, (unsigned long *) arg);
else
put_fs_long(CHARS(&tty->secondary),
(unsigned long *) arg);
return 0;
case TIOCSTI:
return -EINVAL; /* not implemented */
case TIOCGWINSZ:
return get_window_size(tty,(struct winsize *) arg);
case TIOCSWINSZ:
if (IS_A_PTY_MASTER(dev))
set_window_size(other_tty,(struct winsize *) arg);
return set_window_size(tty,(struct winsize *) arg);
case TIOCGSOFTCAR:
return -EINVAL; /* not implemented */
case TIOCSSOFTCAR:
return -EINVAL; /* not implemented */
case TIOCLINUX:
switch (get_fs_byte((char *)arg))
{
case 0:
return do_screendump(arg);
case 1:
return do_get_ps_info(arg);
default:
return -EINVAL;
}
case TIOCCONS:
if (!IS_A_PTY(dev))
return -EINVAL;
if (redirect)
return -EBUSY;
if (!suser())
return -EPERM;
if (IS_A_PTY_MASTER(dev))
redirect = other_tty;
else
redirect = tty;
return 0;
case FIONBIO:
if (arg)
file->f_flags |= O_NONBLOCK;
else
file->f_flags &= ~O_NONBLOCK;
return 0;
case TIOCNOTTY:
if (MINOR(file->f_rdev) != current->tty)
return -EINVAL;
current->tty = -1;
if (current->leader) {
if (tty->pgrp > 0)
kill_pg(tty->pgrp, SIGHUP, 0);
tty->pgrp = -1;
tty->session = 0;
}
return 0;
case TIOCPKT:
{
int on;
if (!IS_A_PTY_MASTER(dev))
return (-EINVAL);
verify_area ((unsigned long *)arg, sizeof (int));
on=get_fs_long ((unsigned long *)arg);
if (on )
tty->packet = 1;
else
tty->packet = 0;
return (0);
}
default:
if (tty->ioctl)
return (tty->ioctl)(tty, file, cmd, arg);
else
return -EINVAL;
}
}
int tty_ioctl(int dev, int cmd, int arg)
{
struct tty_struct * tty;
struct tty_struct * other_tty;
int pgrp;
if (MAJOR(dev) == 5) {
dev = current->tty;
if (dev<0)
return -EINVAL;
} else
dev=MINOR(dev);
tty = tty_table + (dev ? ((dev < 64)? dev-1:dev) : fg_console);
if (IS_A_PTY(dev))
other_tty = tty_table + PTY_OTHER(dev);
else
other_tty = NULL;
if (!(tty->write_q && tty->read_q && tty->secondary && tty->write))
return -EINVAL;
switch (cmd) {
case TCGETS:
return get_termios(tty,(struct termios *) arg);
case TCSETSF:
flush(tty->read_q);
flush(tty->secondary);
if (other_tty)
flush(other_tty->write_q);
/* fallthrough */
case TCSETSW:
wait_until_sent(tty);
/* fallthrough */
case TCSETS:
return set_termios(tty,(struct termios *) arg, dev);
case TCGETA:
return get_termio(tty,(struct termio *) arg);
case TCSETAF:
flush(tty->read_q);
flush(tty->secondary);
if (other_tty)
flush(other_tty->write_q);
/* fallthrough */
case TCSETAW:
wait_until_sent(tty); /* fallthrough */
case TCSETA:
return set_termio(tty,(struct termio *) arg, dev);
case TCSBRK:
if (!arg) {
wait_until_sent(tty);
send_break(tty);
}
return 0;
case TCXONC:
switch (arg) {
case TCOOFF:
tty->stopped = 1;
tty->write(tty);
return 0;
case TCOON:
tty->stopped = 0;
tty->write(tty);
return 0;
case TCIOFF:
if (STOP_CHAR(tty))
PUTCH(STOP_CHAR(tty),tty->write_q);
return 0;
case TCION:
if (START_CHAR(tty))
PUTCH(START_CHAR(tty),tty->write_q);
return 0;
}
return -EINVAL; /* not implemented */
case TCFLSH:
if (arg==0) {
flush(tty->read_q);
flush(tty->secondary);
if (other_tty)
flush(other_tty->write_q);
} else if (arg==1)
flush(tty->write_q);
else if (arg==2) {
flush(tty->read_q);
flush(tty->secondary);
flush(tty->write_q);
if (other_tty)
flush(other_tty->write_q);
} else
return -EINVAL;
return 0;
case TIOCEXCL:
return -EINVAL; /* not implemented */
case TIOCNXCL:
return -EINVAL; /* not implemented */
case TIOCSCTTY:
return -EINVAL; /* set controlling term NI */
case TIOCGPGRP:
verify_area((void *) arg,4);
put_fs_long(tty->pgrp,(unsigned long *) arg);
return 0;
case TIOCSPGRP:
if ((current->tty < 0) ||
(current->tty != dev) ||
(tty->session != current->session))
return -ENOTTY;
pgrp=get_fs_long((unsigned long *) arg);
if (pgrp < 0)
return -EINVAL;
if (session_of_pgrp(pgrp) != current->session)
return -EPERM;
tty->pgrp = pgrp;
return 0;
case TIOCOUTQ:
verify_area((void *) arg,4);
put_fs_long(CHARS(tty->write_q),(unsigned long *) arg);
return 0;
case TIOCINQ:
verify_area((void *) arg,4);
put_fs_long(CHARS(tty->secondary),
(unsigned long *) arg);
return 0;
case TIOCSTI:
return -EINVAL; /* not implemented */
case TIOCGWINSZ:
return get_window_size(tty,(struct winsize *) arg);
case TIOCSWINSZ:
if (other_tty)
set_window_size(other_tty,(struct winsize *) arg);
return set_window_size(tty,(struct winsize *) arg);
case TIOCMGET:
return -EINVAL; /* not implemented */
case TIOCMBIS:
return -EINVAL; /* not implemented */
case TIOCMBIC:
return -EINVAL; /* not implemented */
case TIOCMSET:
return -EINVAL; /* not implemented */
case TIOCGSOFTCAR:
return -EINVAL; /* not implemented */
case TIOCSSOFTCAR:
return -EINVAL; /* not implemented */
case TIOCLINUX:
switch (get_fs_byte((char *)arg))
{
case 0:
return do_screendump(arg);
case 1:
return do_get_ps_info(arg);
default:
return -EINVAL;
}
default:
return -EINVAL;
}
}
