Class: IO
- Inherits:
-
Object
- Object
- IO
- Defined in:
- (unknown)
Defined Under Namespace
Modules: generic_readable
Class Method Summary collapse
-
.console(*args) ⇒ Object
Returns an File instance opened console.
-
.default_console_size ⇒ Object
frozen_string_literal: false fallback to console window size.
Instance Method Summary collapse
- #beep ⇒ Object
-
#cooked {|io| ... } ⇒ Object
Yields
self
within cooked mode. -
#cooked! ⇒ Object
Enables cooked mode.
- #cursor ⇒ Object
- #cursor=(cpos) ⇒ Object
-
#echo=(flag) ⇒ Object
Enables/disables echo back.
-
#echo? ⇒ Boolean
Returns
true
if echo back is enabled. -
#getch(min: nil, time: nil) ⇒ String
Reads and returns a character in raw mode.
-
#getpass(prompt = nil) ⇒ String
Reads and returns a line without echo back.
- #goto(x, y) ⇒ Object
-
#iflush ⇒ Object
Flushes input buffer in kernel.
-
#ioflush ⇒ Object
Flushes input and output buffers in kernel.
-
#noecho {|io| ... } ⇒ Object
Yields
self
with disabling echo back. -
#nonblock(*args) ⇒ Object
Yields
self
in non-blocking mode. -
#nonblock=(boolean) ⇒ Boolean
Enables non-blocking mode on a stream when set to
true
, and blocking mode when set tofalse
. -
#nonblock? ⇒ Boolean
Returns
true
if an IO object is in non-blocking mode. -
#nread ⇒ Integer
Returns number of bytes that can be read without blocking.
-
#oflush ⇒ Object
Flushes output buffer in kernel.
- #pressed?(k) ⇒ Boolean
-
#raw(min: nil, time: nil) {|io| ... } ⇒ Object
Yields
self
within raw mode. -
#raw!(min: nil, time: nil) ⇒ Object
Enables raw mode.
-
#ready? ⇒ true, ...
Returns true if input available without blocking, or false.
-
#wait(*args) ⇒ Object
Waits until IO is readable without blocking and returns
self
, ornil
when times out. -
#wait_readable(*args) ⇒ Object
Waits until IO is readable without blocking and returns
self
, ornil
when times out. -
#wait_writable(*args) ⇒ Object
Waits until IO is writable without blocking and returns
self
ornil
when times out. -
#winsize ⇒ Array
Returns console size.
-
#winsize=(size) ⇒ Object
Tries to set console size.
Class Method Details
.console ⇒ #<File:/dev/tty .console(sym, *args) ⇒ Object
Returns an File instance opened console.
If sym
is given, it will be sent to the opened console with args
and the result will be returned instead of the console IO itself.
You must require ‘io/console’ to use this method.
754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 |
# File 'console/console.c', line 754
static VALUE
console_dev(int argc, VALUE *argv, VALUE klass)
{
VALUE con = 0;
rb_io_t *fptr;
VALUE sym = 0;
rb_check_arity(argc, 0, UNLIMITED_ARGUMENTS);
if (argc) {
Check_Type(sym = argv[0], T_SYMBOL);
}
if (klass == rb_cIO) klass = rb_cFile;
if (rb_const_defined(klass, id_console)) {
con = rb_const_get(klass, id_console);
if (!RB_TYPE_P(con, T_FILE) ||
(!(fptr = RFILE(con)->fptr) || GetReadFD(fptr) == -1)) {
rb_const_remove(klass, id_console);
con = 0;
}
}
if (sym) {
if (sym == ID2SYM(id_close) && argc == 1) {
if (con) {
rb_io_close(con);
rb_const_remove(klass, id_console);
con = 0;
}
return Qnil;
}
}
if (!con) {
VALUE args[2];
#if defined HAVE_TERMIOS_H || defined HAVE_TERMIO_H || defined HAVE_SGTTY_H
# define CONSOLE_DEVICE "/dev/tty"
#elif defined _WIN32
# define CONSOLE_DEVICE "con$"
# define CONSOLE_DEVICE_FOR_READING "conin$"
# define CONSOLE_DEVICE_FOR_WRITING "conout$"
#endif
#ifndef CONSOLE_DEVICE_FOR_READING
# define CONSOLE_DEVICE_FOR_READING CONSOLE_DEVICE
#endif
#ifdef CONSOLE_DEVICE_FOR_WRITING
VALUE out;
rb_io_t *ofptr;
#endif
int fd;
#ifdef CONSOLE_DEVICE_FOR_WRITING
fd = rb_cloexec_open(CONSOLE_DEVICE_FOR_WRITING, O_RDWR, 0);
if (fd < 0) return Qnil;
rb_update_max_fd(fd);
args[1] = INT2FIX(O_WRONLY);
args[0] = INT2NUM(fd);
out = rb_class_new_instance(2, args, klass);
#endif
fd = rb_cloexec_open(CONSOLE_DEVICE_FOR_READING, O_RDWR, 0);
if (fd < 0) {
#ifdef CONSOLE_DEVICE_FOR_WRITING
rb_io_close(out);
#endif
return Qnil;
}
rb_update_max_fd(fd);
args[1] = INT2FIX(O_RDWR);
args[0] = INT2NUM(fd);
con = rb_class_new_instance(2, args, klass);
GetOpenFile(con, fptr);
fptr->pathv = rb_obj_freeze(rb_str_new2(CONSOLE_DEVICE));
#ifdef CONSOLE_DEVICE_FOR_WRITING
GetOpenFile(out, ofptr);
ofptr->pathv = fptr->pathv;
fptr->tied_io_for_writing = out;
ofptr->mode |= FMODE_SYNC;
#endif
fptr->mode |= FMODE_SYNC;
rb_const_set(klass, id_console, con);
}
if (sym) {
return rb_f_send(argc, argv, con);
}
return con;
}
|
.default_console_size ⇒ Object
frozen_string_literal: false fallback to console window size
3 4 5 6 7 8 |
# File 'console/lib/console/size.rb', line 3 def IO.default_console_size [ ENV["LINES"].to_i.nonzero? || 25, ENV["COLUMNS"].to_i.nonzero? || 80, ] end |
Instance Method Details
#beep ⇒ Object
650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 |
# File 'console/console.c', line 650
static VALUE
console_beep(VALUE io)
{
rb_io_t *fptr;
int fd;
GetOpenFile(io, fptr);
fd = GetWriteFD(fptr);
#ifdef _WIN32
(void)fd;
MessageBeep(0);
#else
if (write(fd, "\a", 1) < 0)
rb_sys_fail(0);
#endif
return io;
}
|
#cooked {|io| ... } ⇒ Object
Yields self
within cooked mode.
STDIN.cooked(&:gets)
will read and return a line with echo back and line editing.
You must require ‘io/console’ to use this method.
347 348 349 350 351 |
# File 'console/console.c', line 347
static VALUE
console_cooked(VALUE io)
{
return ttymode(io, rb_yield, set_cookedmode, NULL);
}
|
#cooked! ⇒ Object
Enables cooked mode.
If the terminal mode needs to be back, use io.cooked { … }.
You must require ‘io/console’ to use this method.
363 364 365 366 367 368 369 370 371 372 373 374 375 376 |
# File 'console/console.c', line 363
static VALUE
console_set_cooked(VALUE io)
{
conmode t;
rb_io_t *fptr;
int fd;
GetOpenFile(io, fptr);
fd = GetReadFD(fptr);
if (!getattr(fd, &t)) rb_sys_fail(0);
set_cookedmode(&t, NULL);
if (!setattr(fd, &t)) rb_sys_fail(0);
return io;
}
|
#cursor ⇒ Object
686 687 688 689 690 691 692 693 694 695 696 697 698 699 |
# File 'console/console.c', line 686
static VALUE
console_cursor_pos(VALUE io)
{
rb_io_t *fptr;
int fd;
rb_console_size_t ws;
GetOpenFile(io, fptr);
fd = GetWriteFD(fptr);
if (!GetConsoleScreenBufferInfo((HANDLE)rb_w32_get_osfhandle(fd), &ws)) {
rb_syserr_fail(LAST_ERROR, 0);
}
return rb_assoc_new(UINT2NUM(ws.dwCursorPosition.X), UINT2NUM(ws.dwCursorPosition.Y));
}
|
#cursor=(cpos) ⇒ Object
701 702 703 704 705 706 707 |
# File 'console/console.c', line 701
static VALUE
console_cursor_set(VALUE io, VALUE cpos)
{
cpos = rb_convert_type(cpos, T_ARRAY, "Array", "to_ary");
if (RARRAY_LEN(cpos) != 2) rb_raise(rb_eArgError, "expected 2D coordinate");
return console_goto(io, RARRAY_AREF(cpos, 0), RARRAY_AREF(cpos, 1));
}
|
#echo=(flag) ⇒ Object
Enables/disables echo back. On some platforms, all combinations of this flags and raw/cooked mode may not be valid.
You must require ‘io/console’ to use this method.
427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 |
# File 'console/console.c', line 427
static VALUE
console_set_echo(VALUE io, VALUE f)
{
conmode t;
rb_io_t *fptr;
int fd;
GetOpenFile(io, fptr);
fd = GetReadFD(fptr);
if (!getattr(fd, &t)) rb_sys_fail(0);
if (RTEST(f))
set_echo(&t, NULL);
else
set_noecho(&t, NULL);
if (!setattr(fd, &t)) rb_sys_fail(0);
return io;
}
|
#echo? ⇒ Boolean
Returns true
if echo back is enabled.
You must require ‘io/console’ to use this method.
453 454 455 456 457 458 459 460 461 462 463 464 |
# File 'console/console.c', line 453
static VALUE
console_echo_p(VALUE io)
{
conmode t;
rb_io_t *fptr;
int fd;
GetOpenFile(io, fptr);
fd = GetReadFD(fptr);
if (!getattr(fd, &t)) rb_sys_fail(0);
return echo_p(&t) ? Qtrue : Qfalse;
}
|
#getch(min: nil, time: nil) ⇒ String
Reads and returns a character in raw mode.
You must require ‘io/console’ to use this method.
392 393 394 395 396 397 |
# File 'console/console.c', line 392
static VALUE
console_getch(int argc, VALUE *argv, VALUE io)
{
rawmode_arg_t opts, *optp = rawmode_opt(argc, argv, &opts);
return ttymode(io, getc_call, set_rawmode, optp);
}
|
#getpass(prompt = nil) ⇒ String
Reads and returns a line without echo back. Prints prompt
unless it is nil
.
You must require ‘io/console’ to use this method.
892 893 894 895 896 897 898 899 900 901 902 903 |
# File 'console/console.c', line 892
static VALUE
console_getpass(int argc, VALUE *argv, VALUE io)
{
VALUE str, wio;
rb_check_arity(argc, 0, 1);
wio = rb_io_get_write_io(io);
if (wio == io && io == rb_stdin) wio = rb_stderr;
prompt(argc, argv, wio);
str = rb_ensure(getpass_call, io, puts_call, wio);
return str_chomp(str);
}
|
#goto(x, y) ⇒ Object
669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 |
# File 'console/console.c', line 669
static VALUE
console_goto(VALUE io, VALUE x, VALUE y)
{
rb_io_t *fptr;
int fd;
COORD pos;
GetOpenFile(io, fptr);
fd = GetWriteFD(fptr);
pos.X = NUM2UINT(x);
pos.Y = NUM2UINT(y);
if (!SetConsoleCursorPosition((HANDLE)rb_w32_get_osfhandle(fd), pos)) {
rb_syserr_fail(LAST_ERROR, 0);
}
return io;
}
|
#iflush ⇒ Object
Flushes input buffer in kernel.
You must require ‘io/console’ to use this method.
581 582 583 584 585 586 587 588 589 590 591 592 593 594 |
# File 'console/console.c', line 581
static VALUE
console_iflush(VALUE io)
{
rb_io_t *fptr;
int fd;
GetOpenFile(io, fptr);
fd = GetReadFD(fptr);
#if defined HAVE_TERMIOS_H || defined HAVE_TERMIO_H
if (tcflush(fd, TCIFLUSH)) rb_sys_fail(0);
#endif
(void)fd;
return io;
}
|
#ioflush ⇒ Object
Flushes input and output buffers in kernel.
You must require ‘io/console’ to use this method.
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 |
# File 'console/console.c', line 627
static VALUE
console_ioflush(VALUE io)
{
rb_io_t *fptr;
#if defined HAVE_TERMIOS_H || defined HAVE_TERMIO_H
int fd1, fd2;
#endif
GetOpenFile(io, fptr);
#if defined HAVE_TERMIOS_H || defined HAVE_TERMIO_H
fd1 = GetReadFD(fptr);
fd2 = GetWriteFD(fptr);
if (fd2 != -1 && fd1 != fd2) {
if (tcflush(fd1, TCIFLUSH)) rb_sys_fail(0);
if (tcflush(fd2, TCOFLUSH)) rb_sys_fail(0);
}
else {
if (tcflush(fd1, TCIOFLUSH)) rb_sys_fail(0);
}
#endif
return io;
}
|
#noecho {|io| ... } ⇒ Object
Yields self
with disabling echo back.
STDIN.noecho(&:gets)
will read and return a line without echo back.
You must require ‘io/console’ to use this method.
411 412 413 414 415 |
# File 'console/console.c', line 411
static VALUE
console_noecho(VALUE io)
{
return ttymode(io, rb_yield, set_noecho, NULL);
}
|
#nonblock {|io| ... } ⇒ IO #nonblock(boolean) {|io| ... } ⇒ IO
Yields self
in non-blocking mode.
When false
is given as an argument, self
is yielded in blocking mode. The original mode is restored after the block is executed.
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 |
# File 'nonblock/nonblock.c', line 109
static VALUE
rb_io_nonblock_block(int argc, VALUE *argv, VALUE io)
{
int nb = 1;
rb_io_t *fptr;
int f, restore[2];
GetOpenFile(io, fptr);
if (argc > 0) {
VALUE v;
rb_scan_args(argc, argv, "01", &v);
nb = RTEST(v);
}
f = io_nonblock_mode(fptr->fd);
restore[0] = fptr->fd;
restore[1] = f;
if (!io_nonblock_set(fptr->fd, f, nb))
return rb_yield(io);
return rb_ensure(rb_yield, io, io_nonblock_restore, (VALUE)restore);
}
|
#nonblock=(boolean) ⇒ Boolean
Enables non-blocking mode on a stream when set to true
, and blocking mode when set to false
.
78 79 80 81 82 83 84 85 86 87 88 |
# File 'nonblock/nonblock.c', line 78
static VALUE
rb_io_nonblock_set(VALUE io, VALUE nb)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
if (RTEST(nb))
rb_io_set_nonblock(fptr);
else
io_nonblock_set(fptr->fd, io_nonblock_mode(fptr->fd), RTEST(nb));
return io;
}
|
#nonblock? ⇒ Boolean
Returns true
if an IO object is in non-blocking mode.
39 40 41 42 43 44 45 46 47 |
# File 'nonblock/nonblock.c', line 39
static VALUE
rb_io_nonblock_p(VALUE io)
{
rb_io_t *fptr;
GetOpenFile(io, fptr);
if (io_nonblock_mode(fptr->fd) & O_NONBLOCK)
return Qtrue;
return Qfalse;
}
|
#nread ⇒ Integer
Returns number of bytes that can be read without blocking. Returns zero if no information available.
79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 |
# File 'wait/wait.c', line 79
static VALUE
io_nread(VALUE io)
{
rb_io_t *fptr;
int len;
ioctl_arg n;
GetOpenFile(io, fptr);
rb_io_check_readable(fptr);
len = rb_io_read_pending(fptr);
if (len > 0) return INT2FIX(len);
if (!FIONREAD_POSSIBLE_P(fptr->fd)) return INT2FIX(0);
if (ioctl(fptr->fd, FIONREAD, &n)) return INT2FIX(0);
if (n > 0) return ioctl_arg2num(n);
return INT2FIX(0);
}
|
#oflush ⇒ Object
Flushes output buffer in kernel.
You must require ‘io/console’ to use this method.
604 605 606 607 608 609 610 611 612 613 614 615 616 617 |
# File 'console/console.c', line 604
static VALUE
console_oflush(VALUE io)
{
rb_io_t *fptr;
int fd;
GetOpenFile(io, fptr);
fd = GetWriteFD(fptr);
#if defined HAVE_TERMIOS_H || defined HAVE_TERMIO_H
if (tcflush(fd, TCOFLUSH)) rb_sys_fail(0);
#endif
(void)fd;
return io;
}
|
#pressed?(k) ⇒ Boolean
711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 |
# File 'console/console.c', line 711
static VALUE
console_key_pressed_p(VALUE io, VALUE k)
{
int vk = -1;
if (FIXNUM_P(k)) {
vk = NUM2UINT(k);
}
else {
const struct vktable *t;
if (SYMBOL_P(k)) {
k = rb_sym2str(k);
}
else {
StringValueCStr(k);
}
t = console_win32_vk(RSTRING_PTR(k), RSTRING_LEN(k));
if (!t || (vk = (short)t->vk) == -1) {
rb_raise(rb_eArgError, "unknown virtual key code: %"PRIsVALUE, k);
}
}
return GetKeyState(vk) & 0x80 ? Qtrue : Qfalse;
}
|
#raw(min: nil, time: nil) {|io| ... } ⇒ Object
Yields self
within raw mode.
STDIN.raw(&:gets)
will read and return a line without echo back and line editing.
You must require ‘io/console’ to use this method.
302 303 304 305 306 307 |
# File 'console/console.c', line 302
static VALUE
console_raw(int argc, VALUE *argv, VALUE io)
{
rawmode_arg_t opts, *optp = rawmode_opt(argc, argv, &opts);
return ttymode(io, rb_yield, set_rawmode, optp);
}
|
#raw!(min: nil, time: nil) ⇒ Object
Enables raw mode.
If the terminal mode needs to be back, use io.raw { … }.
You must require ‘io/console’ to use this method.
319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 |
# File 'console/console.c', line 319
static VALUE
console_set_raw(int argc, VALUE *argv, VALUE io)
{
conmode t;
rb_io_t *fptr;
int fd;
rawmode_arg_t opts, *optp = rawmode_opt(argc, argv, &opts);
GetOpenFile(io, fptr);
fd = GetReadFD(fptr);
if (!getattr(fd, &t)) rb_sys_fail(0);
set_rawmode(&t, optp);
if (!setattr(fd, &t)) rb_sys_fail(0);
return io;
}
|
#ready? ⇒ true, ...
Returns true if input available without blocking, or false. Returns nil if no information available.
104 105 106 107 108 109 110 111 112 113 114 115 116 |
# File 'wait/wait.c', line 104
static VALUE
io_ready_p(VALUE io)
{
rb_io_t *fptr;
struct timeval tv = {0, 0};
GetOpenFile(io, fptr);
rb_io_check_readable(fptr);
if (rb_io_read_pending(fptr)) return Qtrue;
if (wait_for_single_fd(fptr, RB_WAITFD_IN, &tv))
return Qtrue;
return Qfalse;
}
|
#wait ⇒ true? #wait(timeout) ⇒ true? #wait_readable ⇒ true? #wait_readable(timeout) ⇒ true?
Waits until IO is readable without blocking and returns self
, or nil
when times out. Returns true
immediately when buffered data is available.
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 |
# File 'wait/wait.c', line 130
static VALUE
io_wait_readable(int argc, VALUE *argv, VALUE io)
{
rb_io_t *fptr;
struct timeval timerec;
struct timeval *tv;
GetOpenFile(io, fptr);
rb_io_check_readable(fptr);
tv = get_timeout(argc, argv, &timerec);
if (rb_io_read_pending(fptr)) return Qtrue;
if (wait_for_single_fd(fptr, RB_WAITFD_IN, tv)) {
return io;
}
return Qnil;
}
|
#wait ⇒ true? #wait(timeout) ⇒ true? #wait_readable ⇒ true? #wait_readable(timeout) ⇒ true?
Waits until IO is readable without blocking and returns self
, or nil
when times out. Returns true
immediately when buffered data is available.
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 |
# File 'wait/wait.c', line 130
static VALUE
io_wait_readable(int argc, VALUE *argv, VALUE io)
{
rb_io_t *fptr;
struct timeval timerec;
struct timeval *tv;
GetOpenFile(io, fptr);
rb_io_check_readable(fptr);
tv = get_timeout(argc, argv, &timerec);
if (rb_io_read_pending(fptr)) return Qtrue;
if (wait_for_single_fd(fptr, RB_WAITFD_IN, tv)) {
return io;
}
return Qnil;
}
|
#wait_writable ⇒ Object #wait_writable(timeout) ⇒ nil
Waits until IO is writable without blocking and returns self
or nil
when times out.
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 |
# File 'wait/wait.c', line 155
static VALUE
io_wait_writable(int argc, VALUE *argv, VALUE io)
{
rb_io_t *fptr;
struct timeval timerec;
struct timeval *tv;
GetOpenFile(io, fptr);
rb_io_check_writable(fptr);
tv = get_timeout(argc, argv, &timerec);
if (wait_for_single_fd(fptr, RB_WAITFD_OUT, tv)) {
return io;
}
return Qnil;
}
|
#winsize ⇒ Array
Returns console size.
You must require ‘io/console’ to use this method.
494 495 496 497 498 499 500 501 502 503 504 505 |
# File 'console/console.c', line 494
static VALUE
console_winsize(VALUE io)
{
rb_io_t *fptr;
int fd;
rb_console_size_t ws;
GetOpenFile(io, fptr);
fd = GetWriteFD(fptr);
if (!getwinsize(fd, &ws)) rb_sys_fail(0);
return rb_assoc_new(INT2NUM(winsize_row(&ws)), INT2NUM(winsize_col(&ws)));
}
|
#winsize=(size) ⇒ Object
Tries to set console size. The effect depends on the platform and the running environment.
You must require ‘io/console’ to use this method.
516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 |
# File 'console/console.c', line 516
static VALUE
console_set_winsize(VALUE io, VALUE size)
{
rb_io_t *fptr;
rb_console_size_t ws;
#if defined _WIN32
HANDLE wh;
int newrow, newcol;
#endif
VALUE row, col, xpixel, ypixel;
const VALUE *sz;
int fd;
GetOpenFile(io, fptr);
size = rb_Array(size);
rb_check_arity(RARRAY_LENINT(size), 2, 4);
sz = RARRAY_CONST_PTR(size);
row = sz[0], col = sz[1], xpixel = sz[2], ypixel = sz[3];
fd = GetWriteFD(fptr);
#if defined TIOCSWINSZ
ws.ws_row = ws.ws_col = ws.ws_xpixel = ws.ws_ypixel = 0;
#define SET(m) ws.ws_##m = NIL_P(m) ? 0 : (unsigned short)NUM2UINT(m)
SET(row);
SET(col);
SET(xpixel);
SET(ypixel);
#undef SET
if (!setwinsize(fd, &ws)) rb_sys_fail(0);
#elif defined _WIN32
wh = (HANDLE)rb_w32_get_osfhandle(fd);
#define SET(m) new##m = NIL_P(m) ? 0 : (unsigned short)NUM2UINT(m)
SET(row);
SET(col);
#undef SET
if (!NIL_P(xpixel)) (void)NUM2UINT(xpixel);
if (!NIL_P(ypixel)) (void)NUM2UINT(ypixel);
if (!GetConsoleScreenBufferInfo(wh, &ws)) {
rb_syserr_fail(LAST_ERROR, "GetConsoleScreenBufferInfo");
}
if ((ws.dwSize.X < newcol && (ws.dwSize.X = newcol, 1)) ||
(ws.dwSize.Y < newrow && (ws.dwSize.Y = newrow, 1))) {
if (!SetConsoleScreenBufferSize(wh, ws.dwSize)) {
rb_syserr_fail(LAST_ERROR, "SetConsoleScreenBufferInfo");
}
}
ws.srWindow.Left = 0;
ws.srWindow.Top = 0;
ws.srWindow.Right = newcol;
ws.srWindow.Bottom = newrow;
if (!SetConsoleWindowInfo(wh, FALSE, &ws.srWindow)) {
rb_syserr_fail(LAST_ERROR, "SetConsoleWindowInfo");
}
#endif
return io;
}
|