terminfo.c

/* terminfo.c - Ruby binding for terminfo library.

Copyright (C) 2007, 2008 Tanaka Akira. All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

 1. Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
 2. Redistributions in binary form must reproduce the above
    copyright notice, this list of conditions and the following
    disclaimer in the documentation and/or other materials provided
    with the distribution.
 3. The name of the author may not be used to endorse or promote
    products derived from this software without specific prior
    written permission.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include "ruby.h"
#ifdef HAVE_RUBY_IO_H
# include "ruby/io.h"
#else
# include "rubyio.h"
#endif
#include "extconf.h"

#if defined(HAVE_NCURSES_H)
#include <ncurses.h>
#elif defined(HAVE_CURSES_H)
#include <curses.h>
#endif

#ifdef HAVE_TERM_H
#include <term.h>
#endif

#include <termios.h>
#include <sys/ioctl.h>
#include <unistd.h>

#ifdef HAVE_WCHAR_H
#include <wchar.h>
#endif

static VALUE cTermInfo;
static VALUE eTermInfoError;

#ifndef HAVE_TYPE_RB_IO_T
typedef OpenFile rb_io_t;
#endif

#if defined(HAVE_RB_IO_T_FD) || defined(HAVE_ST_FD)
# define FILENO(fptr) (fptr->fd)
#else
# define FILENO(fptr) fileno(fptr->f)
#endif

#if (defined(__FreeBSD__) && __FreeBSD_cc_version <= 602001) || \
    defined(__OpenBSD__)
/*
  * warning on FreeBSD
    http://www.FreeBSD.org/cgi/query-pr.cgi?pr=108117&cat=
  * core dump on OpenBSD
    http://cvs.openbsd.org/cgi-bin/query-pr-wrapper?full=yes&textonly=yes&numbers=5447
*/
#define del_curterm(oterm) do {} while(0)
#endif

static void
rt_free(void *ptr)
{
  if(ptr != NULL)
    del_curterm(ptr);
}

static VALUE
rt_alloc(VALUE klass)
{
  return Data_Wrap_Struct(klass, NULL, rt_free, 0);
}

static TERMINAL *
check_rt(VALUE self)
{
    Check_Type(self, T_DATA);
    if (RDATA(self)->dfree != rt_free) {
        rb_raise(rb_eTypeError, "wrong argument type %s (expected TermInfo)",
                 rb_class2name(CLASS_OF(self)));
    }
    return DATA_PTR(self);
}

static void
setup(VALUE self)
{
  TERMINAL *old;
  TERMINAL *term = check_rt(self);
  if (term == NULL) { rb_raise(eTermInfoError, "terminfo object not initialized"); }
  if (cur_term == term)
    return;
  old = set_curterm(term);
}

/*
 * TermInfo#setupterm(term, fd) => int
 *
 * TermInfo#setupterm initializes TermInfo object.
 *
 * term is a string of nil.
 * If nil is given, the environment variable $TERM is used.
 *
 * fd is a file descriptor for target terminal.
 */
static VALUE
rt_setupterm(VALUE self, VALUE v_term, VALUE v_fd)
{
  char *term;
  int fd;
  int err;
  int ret;
  if (check_rt(self) != NULL) { rb_raise(eTermInfoError, "terminfo object already initialized"); }

  if (v_term == Qnil)
    term = NULL;
  else
    term = StringValueCStr(v_term);
  fd = NUM2INT(v_fd);

  ret = setupterm(term, fd, &err);
  if (ret == ERR) {
    if (err == 1) rb_raise(eTermInfoError, "hardcopy terminal");
    else if (err == 0) rb_raise(eTermInfoError, "terminal could not be found");
    else if (err == -1) rb_raise(eTermInfoError, "terminfo database could not be found");
    else rb_raise(eTermInfoError, "unexpected setupterm error");
  }

  DATA_PTR(self) = cur_term;

  return INT2NUM(err);
}

/*
 * TermInfo#tigetflag(capname) => int
 *
 * TermInfo#tigetflag returns a boolean capability specified by capname.
 */
static VALUE
rt_tigetflag(VALUE self, VALUE v_capname)
{
  int ret;
  setup(self);
  ret = tigetflag(StringValueCStr(v_capname));
  if (ret == -1) { rb_raise(eTermInfoError, "not a boolean capability"); }
  return RTEST(ret) ? Qtrue : Qfalse;
}

/*
 * TermInfo#tigetnum(capname) => int
 *
 * TermInfo#tigetnum returns a numeric capability specified by capname.
 */
static VALUE
rt_tigetnum(VALUE self, VALUE v_capname)
{
  int ret;
  setup(self);
  ret = tigetnum(StringValueCStr(v_capname));
  if (ret == -2) { rb_raise(eTermInfoError, "not a numeric capability"); }
  if (ret == -1) { rb_raise(eTermInfoError, "canceled or absent numeric capability"); }
  return INT2NUM(ret);
}

/*
 * TermInfo#tigetstr(capname) => str
 *
 * TermInfo#tigetstr returns a string capability specified by capname.
 *
 * The return value should be printed after tputs is applied.
 * Also tparm should be applied if it has parameters.
 *
 *   io.print ti.tputs(ti.tparm(ti.tigetstr("cuf"), 2))
 *
 * Note that "cuf" means "cursor forward".
 */
static VALUE
rt_tigetstr(VALUE self, VALUE v_capname)
{
  char *ret;
  setup(self);
  ret = tigetstr(StringValueCStr(v_capname));
  if (ret == (char*)-1) {
    rb_raise(eTermInfoError, "not a string capability");
  }
  if (ret == 0) {
    rb_raise(eTermInfoError, "canceled or absent string capability");
  }
  return rb_str_new2(ret);
}

/*
 * TermInfo#tparm(str, ...) => str
 *
 * TermInfo#tparm expands parameters in str returned by tigetstr.
 */
static VALUE
rt_tparm(int argc, VALUE *argv, VALUE self)
{
  char *capname, *ret;
  setup(self);
  VALUE v_capname, v1, v2, v3, v4, v5, v6, v7, v8, v9;
  long p1, p2, p3, p4, p5, p6, p7, p8, p9;
  setup(self);

  if (rb_scan_args(argc, argv, "19", &v_capname, &v1, &v2, &v3, &v4, &v5, &v6, &v7, &v8, &v9) == 0) {
    rb_raise(rb_eArgError, "capname required");
  }

  capname = StringValueCStr(v_capname);
#define conv(p, v) do { if (v == Qnil) p = 0; else p = NUM2LONG(v); } while(0)
  conv(p1, v1);
  conv(p2, v2);
  conv(p3, v3);
  conv(p4, v4);
  conv(p5, v5);
  conv(p6, v6);
  conv(p7, v7);
  conv(p8, v8);
  conv(p9, v9);

  ret = tparm(capname, p1, p2, p3, p4, p5, p6, p7, p8, p9);

  if (ret == NULL) { rb_raise(eTermInfoError, "tparm failed"); }

  return rb_str_new2(ret);
}

static VALUE putfunc_output; /* xxx: not thread safe */

static int
putfunc(int arg)
{
  char ch = arg;
  rb_str_cat(putfunc_output, &ch, 1);
  return arg;
}

/*
 * TermInfo#tputs(str, affcnt) => str
 *
 * TermInfo#tputs expands padding informaiton using padding characters.
 * affcnt is a number of lines affected by the str.
 */
static VALUE
rt_tputs(VALUE self, VALUE v_str, VALUE v_affcnt)
{
  int ret;
  char *str;
  int affcnt;
  VALUE output;

  setup(self);
  str = StringValueCStr(v_str);
  affcnt = NUM2INT(v_affcnt);

  putfunc_output = output = rb_str_new2("");
  ret = tputs(str, affcnt, putfunc);
  putfunc_output = Qnil;

  if (ret == ERR) { rb_raise(eTermInfoError, "tputs failed"); }

  return output;
}

/*
 * TermInfo.tiocgwinsz(io) => [row, col]
 *
 * TermInfo.tiocgwinsz returns the screen size of the terminal refered by io,
 * using TIOCGWINSZ ioctl.
 */
static VALUE
rt_tiocgwinsz(VALUE self, VALUE io)
{
#ifdef TIOCGWINSZ
  rb_io_t *fptr;
  struct winsize sz;
  int ret;

  GetOpenFile(io, fptr);

  ret = ioctl(FILENO(fptr), TIOCGWINSZ, &sz);
  if (ret == -1) rb_raise(rb_eIOError, "TIOCGWINSZ failed");

  return rb_ary_new3(2, INT2NUM(sz.ws_row), INT2NUM(sz.ws_col));
#else
  rb_notimplement();
#endif
}

/*
 * TermInfo.tiocswinsz(io, row, col)
 *
 * TermInfo.tiocgwinsz update the screen size information of the terminal refered by io,
 * using TIOCSWINSZ ioctl.
 *
 * It returns nil.
 */
static VALUE
rt_tiocswinsz(VALUE self, VALUE io, VALUE row, VALUE col)
{
#ifdef TIOCSWINSZ
  rb_io_t *fptr;
  struct winsize sz;
  int ret;

  GetOpenFile(io, fptr);

  sz.ws_row = NUM2INT(row);
  sz.ws_col = NUM2INT(col);

  ret = ioctl(FILENO(fptr), TIOCSWINSZ, &sz);
  if (ret == -1) rb_raise(rb_eIOError, "TIOCSWINSZ failed");

  return Qnil;
#else
  rb_notimplement();
#endif
}

/*
 * TermInfo.ctermid
 *
 * TermInfo.ctermid returns a pathname for the current controling terminal,
 * such as "/dev/tty".
 */
static VALUE
rt_ctermid(VALUE self)
{
#ifdef HAVE_CTERMID
  char buf[L_ctermid];
  return rb_str_new2(ctermid(buf));
#else
  return rb_str_new2("/dev/tty");
#endif
}

/*
 * TermInfo.wcswidth(str)
 *
 * TermInfo.wcswidth returns a the number of columns of str,
 * according to current locale.
 */
static VALUE
rt_wcswidth(VALUE self, VALUE str)
{
  char *s;
  size_t l, r;
  mbstate_t mbs;
  wchar_t wc;
  long cols;
  int width;

#ifdef HAVE_RUBY_ENCODING_H
  /* The encoding of str is assumed to be the locale encoding on Ruby 1.8. */
  str = rb_str_encode(str, rb_enc_from_encoding(rb_locale_encoding()), 0, Qnil);
#endif

  memset(&mbs,0,sizeof(mbstate_t));

  s = StringValueCStr(str);
  l = RSTRING_LEN(str);

  cols = 0;
  while (0 < l) {
    r = mbrtowc(&wc, s, l, &mbs);
    if (r == 0)
      rb_raise(rb_eArgError, "NUL found");

    width = wcwidth(wc);
    if (width == -1)
      rb_raise(rb_eArgError, "non-printable charactor found");
    cols += width;

    l -= r;
    s += r;
  }

  return LONG2NUM(cols);
}

void
Init_terminfo()
{
  putfunc_output = Qnil;
  rb_global_variable(&putfunc_output);

  cTermInfo = rb_define_class("TermInfo", rb_cData);
  eTermInfoError = rb_define_class_under(cTermInfo, "TermInfoError", rb_eRuntimeError);

  rb_define_alloc_func(cTermInfo, rt_alloc);

  rb_define_method(cTermInfo, "setupterm", rt_setupterm, 2);
  rb_define_method(cTermInfo, "tigetflag", rt_tigetflag, 1);
  rb_define_method(cTermInfo, "tigetnum", rt_tigetnum, 1);
  rb_define_method(cTermInfo, "tigetstr", rt_tigetstr, 1);
  rb_define_method(cTermInfo, "tparm", rt_tparm, -1);
  rb_define_method(cTermInfo, "tputs", rt_tputs, 2);

  rb_define_module_function(cTermInfo, "tiocgwinsz", rt_tiocgwinsz, 1);
  rb_define_module_function(cTermInfo, "tiocswinsz", rt_tiocswinsz, 3);

  rb_define_module_function(cTermInfo, "ctermid", rt_ctermid, 0);

  rb_define_module_function(cTermInfo, "wcswidth", rt_wcswidth, 1);
}