ncurses-ruby 1.2.1 → 1.2.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e2ba9824af40cca5ae667bcc70b466d7ea90e984
+  data.tar.gz: 21255531cdf879a31d1a2a9d7250cfbc80a95723
+SHA512:
+  metadata.gz: d3f7fe8cdd5ea9454360ac27e58de405b9a18123ef8905ce658eec1c6b798b6f610c982326d01737fc04f6fd4e45a580008258d6e8702e6205a551af2067820c
+  data.tar.gz: 76cf8a1045f569f42b01fd6a183e6b491f1ad5103f3ab638722d94d7af46e44f68d25ba5688b156f891740e8d9b7b01069fbfc5525c4240eda3ebcfcba27eed5

data/Changelog.md

@@ -0,0 +1,68 @@
+## 1.2.3 (2014/07/21)
+* Updated documentation. [Earle Clubb](https://github.com/eclubb)
+
+## 1.2.2 (2014/07/10)
+* Updated to work with Ruby 2.1.0.
+* Fix compilation issues on Mac OS X.
+
+## 1.2.1 (2010/10/29)
+* Changed name of gem from ncurses to ncurses-ruby. [Earle Clubb](https://github.com/eclubb)
+* Updated to work with Ruby 1.9.2. [Elliott Cable](https://github.com/elliottcable)
+
+## 1.2.0 (2009/03/04)
+* Renamed extension from ncurses_bin.so to ncurses.so. [Earle Clubb](https://github.com/eclubb)
+* Added a wrapper for ncurses menu functionality. [Earle Clubb](https://github.com/eclubb)
+
+## 1.1.0
+* Bugfixes by T. Sutherland in _tracef and _tracedump.
+
+## 1.0.0
+* Mousemask bugfix from P.Duncan.
+* Solved timing problems that affected visual smoothness of reactions
+  to user input
+* Each SCREEN got back its own "halfdelay" and "cbreak" settings
+
+## 0.9.2
+* Preventing getch and wgetch functions from blocking other ruby threads.
+* Previously ncurses-ruby installed two files named "ncurses.rb" and
+  "ncurses.so". The "ncurses.so" is now renamed to "ncurses_bin.so"
+  to prevent "require 'ncurses'" from accidentally loading only the
+  binary file in case that this is found first in ruby's load path.
+* Reintroduced ability to "include" Ncurses functions:
+  Use "include Ncurses::Namespace" for that. This is implemented via
+  method_missing, so that ncurses functions (some of which have very
+  common names) will not hide other functions defined in the extended
+  scope. (Any existing method_missing function is properly aliased and
+  called after an unsuccessful lookup.)
+
+## 0.9.1
+* Bugfix in *in*str functions (Hiroshi Sainohira)
+* Fix linking error on Mac OS X and some other platforms (Andreas Schwarz)
+
+## 0.9.0
+* Forms wrapper contributed by Simon Kaczor
+* ncurses-ruby now also works with ncurses-4.2
+  (an old release from 1998, needed for Zaurus-port)
+* First binary package for Sharp Zaurus (arm-linux)
+
+## 0.8.0
+* Bugfix: Calls into the ncurses library prior to calling
+  Ncurses::initscr or Ncurses::newterm had previously crashed
+  the Ruby interpreter.
+  Fixed by delaying the binding of most Ncurses functions
+  until after Ncurses::initscr or Ncurses::newterm have been
+  called.
+* Replaced module functions with singleton functions. This
+  means that
+    include Ncurses
+    initscr
+  is no longer possible. Instead, use
+    Ncurses.initscr
+  Reasons: - Consistency. The shortcut has never been possible
+             with all ncurses functions.
+           - Namespace pollution. Some ncurses functions have
+             too common names.
+
+## 0.7.2
+* reintroduced Ncurses::pechochar and Ncurses::redrawwin in the ncurses build.
+  These had been removed by mistake because they did not work with PDCurses.

data/LICENSE.txt

@@ -0,0 +1,17 @@
+Copyright (c) 2002, 2003, 2004 Tobias Peters <t-peters@users.berlios.de>
+Copyright (c) 2004 Simon Kaczor <skaczor@cox.net>
+Copyright (c) 2005 2006 Tobias Herzke <t-peters@users.berlios.de>
+
+This module is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This module is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this module; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA

data/README.md

@@ -0,0 +1,327 @@
+# ncurses-ruby
+
+A Ruby module for accessing the ncurses library
+
+## Overview
+
+This README file explains how to use the ncurses ruby interface. It is assumed
+that the reader has a rough understanding of what the ncurses library is and
+how to use it from the C language. It then goes into detail, explaining what is
+covered by the ruby interface, and the rules that were followed in translating
+the C interface into a ruby interface.
+
+This ncurses interface provides access to the functions, macros, global
+variables and constants of the ncurses library. These are mapped to a Ruby
+Module named "Ncurses": Functions and external variables are implemented as
+singleton functions of the `Ncurses` module.
+
+This README is organized into the following parts:
+
+- Overview
+- [Installation](#installation)
+- [Usage](#usage)
+- [External Variables](#external-variables)
+- [Constants](#constants-static-c-preprocessor-macros)
+- [Functions (and their Interfaces)](#functions-and-their-interfaces)
+- [Module / Class Hierarchy](#module--class-hierarchy)
+- [The WINDOW class](#the-window-class)
+- [The panel Library](#the-panel-library)
+- [The form Library](#the-form-library)
+- [The menu Library](#the-menu-library)
+- [Ncurses and Ruby Threads](#ncurses-and-ruby-threads)
+- [Example programs](#example-programs)
+- [Contributing](#contributing)
+
+### General Ncurses Literature
+
+If you don't know how to use ncurses from C, then please read an introduction
+to ncurses before continuing with this README. Eric Raymond has written an
+introduction that should be part of the ncurses development package installed
+on your computer.  If you'd like a gentler introduction, then you have two
+options:
+
+1. there is a part of a chapter in "The Linux Programmer's Guide" dealing with
+   ncurses, available from www.tldp.org.  It is quite old by now, but the
+   ncurses interface has not changed since then, regarding the scope of covered
+   functions, so it is still a very good read.
+2. There is also an up-to-date "NCURSES-Programming-HOWTO" in the HOWTO
+   collection of the Linux Documentation Project, also available at
+   www.tldp.org, which is worth a read.
+
+You will also appreciate the extensive man-pages of ncurses, a useful reference
+while coding.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ncurses-ruby'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ncurses-ruby
+
+## Usage
+
+In your programs:
+
+```ruby
+require 'ncurses.rb'
+```
+
+If your programs use the scanw functions (most unlikely) you will have to
+install the [scanf](http://www.rubyhacker.com/code/scanf) library for ruby.
+
+Most ncurses functions are only available after either `Ncurses.initscr` or
+`Ncurses.newterm` has returned successfully.
+
+## External Variables
+
+External variables are accessed read-only, by module functions taking no
+arguments.  They are spelled exactly like their C counterparts. Sometimes, this
+leads to module functions beginning with an uppercase letter (e.g.
+`Ncurses.LINES`).
+
+One of these external variables, `Ncurses.ESCDELAY`, is also settable with a
+ruby method (`Ncurses.ESCDELAY=`).
+
+Another external variable, `Ncurses.RESIZEDELAY` is introduced by this wrapper.
+It contains the maximum milliseconds delay with which terminal resizesings are
+recognized.
+
+## Constants (static C Preprocessor macros)
+
+Constants are implemented as module constants in the Ncurses module, if
+possible. Ruby constants can not start with an underscore, so these constants
+have been renamed (they lost the leading underscore). There are,however, module
+functions with the same name as these constants, that also return the
+constant's value, when invoked (e.g. `Ncurses._ENDLINE` returns the value of
+the constant `Ncurses::ENDLINE`, which has the same value as the C constant
+`_ENDLINE`).
+
+Note: The ncurses macros starting with `ACS_` are not constants, their value
+depends on the terminal in use.  Nevertheless, they are implemented as
+constants of the Ncurses module, but since they depend on the terminal, they
+are not initialized before `initscr` has been called. If you need more than one
+terminal in a single program, you can access the `ACS_` values through member
+functions of class `SCREEN`.
+
+## Functions (and their Interfaces)
+
+Functions (also those only implemented by macros in C) can be accessed as
+module functions of the `Ncurses` module. They take exactly the same arguments
+as their C counterparts. Some of the C functions return additional arguments
+through pointer arguments. These are implemented as follows:
+
+### Functions expecting pointers to integer types
+
+When the C-function expects a pointer to `int`, `short`, `chtype`, or `attr_type`, you
+should use a variable containing an empty array as the argument to the ruby
+function. This is because ruby passes these types (ints) "by value" instead of
+"by reference"; but arrays are passed by reference, so that you can see the
+changes to them.
+
+Attention: some macro-only functions like `getsyx` accept variables of type
+int, but, being macros, they write values to their arguments.  Thus, they also
+need empty array arguments when called from ruby.
+
+Example:
+
+```ruby
+color_pair_number = 4
+foreground_color  = []
+background_color  = []
+if (Ncurses.pair_content(color_pair_number, foreground_color, background_color) != Ncurses::ERR)
+  "color pair number #{color_pair_number} contains color number " +
+  "#{foreground_color[0]} as the foreground color, and color "    +
+  "number #{background_color[0]} as the background color")
+end
+```
+
+There are 2 functions that read a value from the location pointed to by a
+pointer to int, and store another value at those locations. These functions are
+`mouse_trafo` and `wmouse_trafo`. When calling these functions, you have to
+provide 2 arrays, each filled with exacly one integer. The values contained in
+these arrays will then be changed by the ruby module function.
+
+### Functions expecting (non-const) pointers to char
+
+When the C-function expects a pointer to char, you should use a variable
+containing an empty string as the argument to the ruby function.
+
+Example:
+
+```ruby
+line2 = ""
+if (Ncurses.mvwinnstr(Ncurses.stdscr, y=2, x=0, line2, Ncurses.getmaxx(Ncurses.stdscr)) == Ncurses::ERR)
+  raise "could not scan 3rd line"
+else
+  Ncurses.beep if line2.index("|")
+end
+```
+
+The string that the C function would store at the pointer-to-char location will
+be appended to the given string.
+
+Functions expecting const pointers to char do not modify the string they
+receive, you can pass any string to them.
+
+### Functions expecting pointers to structs
+
+When the C-function expects a pointer to `WINDOW`, `SCREEN`, `MEVENT`, `PANEL`,
+`FORM`, `FIELD`, or `FIELDTYPE` then simply pass it the corresponding, already
+existing ruby object.
+
+### scanf-style functions expecting various pointers
+
+Namely `scanw`, `mvscanw`, `wscanw`, and `mvwscanw`.  Use an array after the
+format string.  The scanned values will be placed there. Remember, you need
+[scanf](http://www.rubyhacker.com/code/scanf) for ruby installed for these
+functions to work.
+
+## Module / Class Hierarchy
+
+```ruby
+module Ncurses
+  class WINDOW; end
+  class SCREEN; end
+  class MEVENT; end
+  module Panel
+    class PANEL; end
+  end
+  module Form
+    class FORM; end
+    class FIELD; end
+    class FIELDTYPE; end
+  end
+  module Menu
+    class MENU; end
+    class ITEM; end
+  end
+end
+```
+
+## The `WINDOW` class
+
+The class `WINDOW` implements `method_missing` and tries to map invoked methods
+to `Ncurses` module functions using a simple heuristic:
+
+If the method name starts with "mv", it looks for an `Ncurses` module function
+that starts with "mvw", and if it exists, adds itself to the argument list and
+calls this function.
+If no such module function exists, or the name of the invoked method does not
+start with "mv", it looks to see if there is a module function with the name
+"w" + methodname, and if it exists, adds itself again to the argument list and
+calls this function.
+If this module function did not exist either, then, as a last step, it invokes
+a module function with the same name as the method, adding itself to the
+argument list.
+
+Example: If you invoke `mvaddch(y,x,ch)` on an `Ncurses::WINDOW` object, it
+will delegate the method call to `Ncurses.mvwaddch(win,y,x,ch)`.
+
+Other examples:
+
+```ruby
+ win.printw("hello")       =>  Ncurses.wprintw(win, "hello")
+
+ win.getmaxyx(y=[], x=[])  =>  Ncurses.getmaxyx(win,y,x)
+
+ win.delwin                =>  Ncurses.delwin(win)    # win cannot be used
+                                                      # after this call
+```
+
+## The panel Library
+
+The panel library has also been wrapped. All panel functions are
+implemented as module functions of the module `Ncurses::Panel`.
+
+Most of these functions are also implemented as methods of class
+`Ncurses::Panel::PANEL`, once with their original name and once with the
+subword "panel" and an adjacent underscore removed.
+
+## The form Library
+
+The form library was wrapped inside the `Ncurses:Form` module. All form
+functions are implemented as module functions on the module `Ncurses::Form`. In
+addition, all function for which the first parameter is one of the objects are
+also implemented as an instance method of the respective class. For example,
+instead of calling `post_form(form)`, you can use `form.post_form`.
+
+Three objects are defined in the `Ncurses::Form` module:
+
+1. FORM
+2. FIELD
+3. FIELDTYPE
+
+They are wrapping actual ncurses pointers and should be use whenever a pointer
+to one of these types is expected in function calls.
+
+All form constants are defined in the module as Ruby constants with the same
+name as the curses constants.
+
+Constructors for `FORM`, `FIELD`, and `FIELDTYPE` objects are also provided,
+and they expect the same parameters as `new_form`, `new_field`, and
+`new_fieldtype` curses functions.
+
+Field validation is implemented using Ruby Proc objects. You must provide a
+Ruby block whenever a function pointer is expected in curses function
+arguments. See the example form2.rb for more details.
+
+The functions `form_userptr` and `field_userptr` are not supported. Use
+`form.user_object` and `field.user_object` to store Ruby objects instead.
+
+## The menu Library
+
+The menu library was wrapped inside the `Ncurses:Menu` module. All menu
+functions are implemented as module functions in the module `Ncurses::Menu`. In
+addition, all functions for which the first parameter is one of the objects are
+also implemented as an instance method of the respective class. For example,
+instead of calling `post_menu(menu)`, you can use `menu.post_menu`.
+
+Two objects are defined in the `Ncurses::Menu` module:
+
+1. MENU
+2. ITEM
+
+They are wrapping actual ncurses pointers and should be use whenever a pointer
+to one of these types is expected in function calls.
+
+All menu constants are defined in the module as Ruby constants with the same
+name as the curses constants.
+
+Constructors for `MENU` and `ITEM` objects are also provided, and they expect
+the same parameters as `new_menu` and `new_item` curses functions.
+
+You must provide a Ruby block whenever a function pointer is expected in curses
+function arguments.
+
+The functions `menu_userptr` and `item_userptr` are not supported. Use
+`menu.user_object` and `item.user_object` to store Ruby objects instead.
+
+## Ncurses and Ruby Threads
+
+The ncurses library is not thread-safe. Your application must properly
+serialize calls into ncurses.
+
+Prior to release 0.9.2, the `getch` and `wgetch` calls used to block the
+complete ruby interpreter, all threads. This is no longer so. Other threads
+should now continue to run during blocking calls to `getch` and `wgetch`.
+
+## Example programs
+
+Directory "examples" contains a few example programs demonstrating how
+to use the ncurses library with ruby.  Be sure to read the file
+"examples/LICENSES_for_examples".
+
+## Contributing
+
+1. Fork it ( https://github.com/eclubb/ncurses-ruby/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/THANKS

@@ -13,3 +13,4 @@ Simon Strandgaard
 Paul Duncan
 Tim Sutherland
 Earle Clubb
+Jeffrey Crowell (crowell at bu dot edu)

data/examples/tclock.rb

@@ -48,7 +48,7 @@ end
 
 # Plot a point
 def plot(x, y, c)
-  Ncurses.mvaddch(y, x, c[0])
+  Ncurses.mvaddch(y, x, c[0].ord)
 end
 
 # Draw a diagonal(arbitrary) line using Bresenham's alogrithm.

data/ext/ncurses/Makefile

@@ -0,0 +1,238 @@
+
+SHELL = /bin/sh
+
+# V=0 quiet, V=1 verbose.  other values don't work.
+V = 0
+Q1 = $(V:1=)
+Q = $(Q1:0=@)
+ECHO1 = $(V:1=@:)
+ECHO = $(ECHO1:0=@echo)
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /home/earle/.rubies/ruby-2.1.1/include/ruby-2.1.0
+hdrdir = $(topdir)
+arch_hdrdir = /home/earle/.rubies/ruby-2.1.1/include/ruby-2.1.0/x86_64-linux
+PATH_SEPARATOR = :
+VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
+prefix = $(DESTDIR)/home/earle/.rubies/ruby-2.1.1
+rubysitearchprefix = $(rubylibprefix)/$(sitearch)
+rubyarchprefix = $(rubylibprefix)/$(arch)
+rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
+exec_prefix = $(prefix)
+vendorarchhdrdir = $(vendorhdrdir)/$(sitearch)
+sitearchhdrdir = $(sitehdrdir)/$(sitearch)
+rubyarchhdrdir = $(rubyhdrdir)/$(arch)
+vendorhdrdir = $(rubyhdrdir)/vendor_ruby
+sitehdrdir = $(rubyhdrdir)/site_ruby
+rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+vendorlibdir = $(vendordir)/$(ruby_version)
+vendordir = $(rubylibprefix)/vendor_ruby
+sitearchdir = $(sitelibdir)/$(sitearch)
+sitelibdir = $(sitedir)/$(ruby_version)
+sitedir = $(rubylibprefix)/site_ruby
+rubyarchdir = $(rubylibdir)/$(arch)
+rubylibdir = $(rubylibprefix)/$(ruby_version)
+sitearchincludedir = $(includedir)/$(sitearch)
+archincludedir = $(includedir)/$(arch)
+sitearchlibdir = $(libdir)/$(sitearch)
+archlibdir = $(libdir)/$(arch)
+ridir = $(datarootdir)/$(RI_BASE_NAME)
+mandir = $(datarootdir)/man
+localedir = $(datarootdir)/locale
+libdir = $(exec_prefix)/lib
+psdir = $(docdir)
+pdfdir = $(docdir)
+dvidir = $(docdir)
+htmldir = $(docdir)
+infodir = $(datarootdir)/info
+docdir = $(datarootdir)/doc/$(PACKAGE)
+oldincludedir = $(DESTDIR)/usr/include
+includedir = $(prefix)/include
+localstatedir = $(prefix)/var
+sharedstatedir = $(prefix)/com
+sysconfdir = $(prefix)/etc
+datadir = $(datarootdir)
+datarootdir = $(prefix)/share
+libexecdir = $(exec_prefix)/libexec
+sbindir = $(exec_prefix)/sbin
+bindir = $(exec_prefix)/bin
+archdir = $(rubyarchdir)
+
+
+CC = gcc
+CXX = g++
+LIBRUBY = $(LIBRUBY_A)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -Wl,-R -Wl,$(libdir) -L$(libdir) 
+LIBRUBYARG_STATIC = -Wl,-R -Wl,$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)-static
+empty =
+OUTFLAG = -o $(empty)
+COUTFLAG = -o $(empty)
+
+RUBY_EXTCONF_H = 
+cflags   =  $(optflags) $(debugflags) $(warnflags)
+optflags = -O3 -fno-fast-math
+debugflags = -ggdb3
+warnflags = -Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wunused-variable -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wimplicit-function-declaration
+CCDLFLAGS = -fPIC
+CFLAGS   = $(CCDLFLAGS) $(cflags) -g -I/usr/pkg/include $(ARCH_FLAG)
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS = -DHAVE_UNISTD_H -DHAVE_NCURSES_H -DHAVE_NEWSCR -DHAVE_TABSIZE -DHAVE_ESCDELAY -DHAVE_KEYBOUND -DHAVE_CURSES_VERSION -DHAVE_TIGETSTR -DHAVE_GETWIN -DHAVE_PUTWIN -DHAVE_UNGETMOUSE -DHAVE_MOUSEMASK -DHAVE_WENCLOSE -DHAVE_MOUSEINTERVAL -DHAVE_WMOUSE_TRAFO -DHAVE_MCPRINT -DHAVE_HAS_KEY -DHAVE_DELSCREEN -DHAVE_DEFINE_KEY -DHAVE_KEYOK -DHAVE_RESIZETERM -DHAVE_USE_DEFAULT_COLORS -DHAVE_USE_EXTENDED_NAMES -DHAVE_WRESIZE -DHAVE_ATTR_ON -DHAVE_ATTR_OFF -DHAVE_ATTR_SET -DHAVE_CHGAT -DHAVE_COLOR_SET -DHAVE_FILTER -DHAVE_INTRFLUSH -DHAVE_MVCHGAT -DHAVE_MVHLINE -DHAVE_MVVLINE -DHAVE_MVWCHGAT -DHAVE_MVWHLINE -DHAVE_MVWVLINE -DHAVE_NOQIFLUSH -DHAVE_PUTP -DHAVE_QIFLUSH -DHAVE_SCR_DUMP -DHAVE_SCR_INIT -DHAVE_SCR_RESTORE -DHAVE_SCR_SET -DHAVE_SLK_ATTR -DHAVE_SLK_ATTR_SET -DHAVE_SLK_COLOR -DHAVE_TIGETFLAG -DHAVE_TIGETNUM -DHAVE_USE_ENV -DHAVE_VIDATTR -DHAVE_WATTR_ON -DHAVE_WATTR_OFF -DHAVE_WATTR_SET -DHAVE_WCHGAT -DHAVE_WCOLOR_SET -DHAVE_GETATTRS -DHAVE_ASSUME_DEFAULT_COLORS -DHAVE_ATTR_GET -DHAVE_PANEL_H -DHAVE_FORM_H -DHAVE_MENU_H  $(DEFS) $(cppflags)
+CXXFLAGS = $(CCDLFLAGS) $(cxxflags) $(ARCH_FLAG)
+ldflags  = -L. -fstack-protector -rdynamic -Wl,-export-dynamic -L/usr/pkg/lib
+dldflags =  
+ARCH_FLAG = 
+DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG)
+LDSHARED = $(CC) -shared
+LDSHAREDXX = $(CXX) -shared
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = ruby
+RUBY_SO_NAME = ruby
+RUBYW_INSTALL_NAME = 
+RUBY_VERSION_NAME = $(RUBY_BASE_NAME)-$(ruby_version)
+RUBYW_BASE_NAME = rubyw
+RUBY_BASE_NAME = ruby
+
+arch = x86_64-linux
+sitearch = $(arch)
+ruby_version = 2.1.0
+ruby = $(bindir)/ruby
+RUBY = $(ruby)
+ruby_headers = $(hdrdir)/ruby.h $(hdrdir)/ruby/ruby.h $(hdrdir)/ruby/defines.h $(hdrdir)/ruby/missing.h $(hdrdir)/ruby/intern.h $(hdrdir)/ruby/st.h $(hdrdir)/ruby/subst.h $(arch_hdrdir)/ruby/config.h
+
+RM = rm -f
+RM_RF = $(RUBY) -run -e rm -- -rf
+RMDIRS = rmdir --ignore-fail-on-non-empty -p
+MAKEDIRS = /usr/bin/mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+TOUCH = exit >
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir)
+LIBPATH =  -L. -L$(libdir) -Wl,-R$(libdir)
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+DISTCLEANDIRS = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS =  -lmenu -lform -lpanel -lncurses  -lpthread -ldl -lcrypt -lm   -lc
+ORIG_SRCS = panel_wrap.c ncurses_wrap.c form_wrap.c menu_wrap.c
+SRCS = $(ORIG_SRCS) 
+OBJS = panel_wrap.o ncurses_wrap.o form_wrap.o menu_wrap.o
+HDRS = $(srcdir)/form_wrap.h $(srcdir)/panel_wrap.h $(srcdir)/ncurses_wrap.h $(srcdir)/menu_wrap.h
+TARGET = ncurses
+TARGET_NAME = ncurses
+TARGET_ENTRY = Init_$(TARGET_NAME)
+DLLIB = $(TARGET).so
+EXTSTATIC = 
+STATIC_LIB = 
+
+TIMESTAMP_DIR = .
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+HDRDIR        = $(rubyhdrdir)/ruby$(target_prefix)
+ARCHHDRDIR    = $(rubyhdrdir)/$(arch)/ruby$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).so 
+CLEANOBJS     = *.o  *.bak
+
+all:    $(DLLIB)
+static: $(STATIC_LIB)
+.PHONY: all install static install-so install-rb
+.PHONY: clean clean-so clean-static clean-rb
+
+clean-static::
+clean-rb-default::
+clean-rb::
+clean-so::
+clean: clean-so clean-static clean-rb-default clean-rb
+		-$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time
+
+distclean-rb-default::
+distclean-rb::
+distclean-so::
+distclean-static::
+distclean: clean distclean-so distclean-static distclean-rb-default distclean-rb
+		-$(Q)$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		-$(Q)$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+		-$(Q)$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true
+
+realclean: distclean
+install: install-so install-rb
+
+install-so: $(DLLIB) $(TIMESTAMP_DIR)/.RUBYARCHDIR.time
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+clean-static::
+	-$(Q)$(RM) $(STATIC_LIB)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+pre-install-rb-default:
+	$(ECHO) installing default ncurses libraries
+$(TIMESTAMP_DIR)/.RUBYARCHDIR.time:
+	$(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR)
+	$(Q) $(TOUCH) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .mm .cxx .cpp .C .o
+
+.cc.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.mm.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cxx.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cpp.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.C.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.c.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+.m.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+$(DLLIB): $(OBJS) Makefile
+	$(ECHO) linking shared-object $(DLLIB)
+	-$(Q)$(RM) $(@)
+	$(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): $(HDRS) $(ruby_headers)