Class: IO

Inherits:
Object
  • Object
show all
Defined in:
(unknown)

Defined Under Namespace

Modules: generic_readable

Class Method Summary collapse

Instance Method Summary collapse

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.

Overloads:

  • .console ⇒ #<File:/dev/tty

    Returns ].

    Returns:

    • (#<File:/dev/tty) —

      ]



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

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.

Yields:

  • (io) 


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.

Returns:

  • (Boolean) 


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.

Returns:

  • (String) 


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.

Returns:

  • (String) 


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.

Yields:

  • (io) 


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.

Overloads:

  • #nonblock {|io| ... } ⇒ IO

    Yields:

    • (io)

    Returns:

  • #nonblock(boolean) {|io| ... } ⇒ IO

    Yields:

    • (io)

    Returns:



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.

Returns:

  • (Boolean) 


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.

Returns:

  • (Boolean) 


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.

Returns:

  • (Integer) 


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

Returns:

  • (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.

Yields:

  • (io) 


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.

Returns:

  • (true, false, nil) 


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.

Overloads:

  • #wait ⇒ true?

    Returns:

    • (true, nil)
  • #wait(timeout) ⇒ true?

    Returns:

    • (true, nil)
  • #wait_readable ⇒ true?

    Returns:

    • (true, nil)
  • #wait_readable(timeout) ⇒ true?

    Returns:

    • (true, nil) 


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.

Overloads:

  • #wait ⇒ true?

    Returns:

    • (true, nil)
  • #wait(timeout) ⇒ true?

    Returns:

    • (true, nil)
  • #wait_readable ⇒ true?

    Returns:

    • (true, nil)
  • #wait_readable(timeout) ⇒ true?

    Returns:

    • (true, nil) 


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.

Overloads:

  • #wait_writable(timeout) ⇒ nil

    Returns:

    • (nil) 


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.

Returns:

  • (Array) 


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;
}