nmea 0.3 → 0.4

data/parser/bod.rl

@@ -0,0 +1,21 @@
+%%{
+	machine NMEA;
+	
+	wpt_to = ((any - ',') @add_char)* comma %{
+		if(*current_string) wpt_to = current_string;
+		current_s = current_string;
+		*current_s = 0;
+	};
+
+	wpt_from = ((any - '*') @add_char)* %{
+		if(*current_string) wpt_from = current_string;
+		current_s = current_string;
+		*current_s = 0;
+	};
+	
+	action read_bod {
+		handler.bod(true_course, magnetic_course, wpt_to, wpt_from);
+	}
+	
+	bod = '$GPBOD,' true_course magnetic_course wpt_to wpt_from checksum;
+}%%

data/parser/gga.rl

@@ -0,0 +1,12 @@
+%%{
+	machine NMEA;
+	gps_quality = ([012345678] @{gps_quality = (GGA_FIX)(fc-'0');}) comma;
+	active_satellite_count = (bcd comma @{active_satellite_count = bcd; }) | comma;
+	altitude = (number comma alpha @{altitude_units = fc;} comma @{altitude = current_float; current_float = 0;}) | comma alpha comma;
+	geoidal_height = (number comma alpha @{geoidal_height_units = fc;} comma @{geoidal_height = current_float; current_float = 0;}) | comma comma;
+	dgps_data = (number comma @{dgps_data_age = current_float; current_float = 0; } |  comma) b4cd @{dgps_station_id = bcd;};
+	action read_gga {
+		handler.gga(utc, latitude, longitude, gps_quality, active_satellite_count, gsa_hdop, altitude, geoidal_height, dgps_data_age, dgps_station_id);
+	}
+	gga = "$GPGGA," utc_time latitude longitude gps_quality active_satellite_count gsa_hdop altitude geoidal_height dgps_data checksum;
+}%%

data/parser/gll.rl

@@ -0,0 +1,8 @@
+%%{
+	machine NMEA;
+	gll_state = 'A' | 'V';
+	action read_gll {
+		handler.gll(utc, latitude, longitude);
+	}
+	gll = "$GPGLL," latitude longitude utc_time gll_state checksum;
+}%%

data/parser/gsa.rl

@@ -0,0 +1,14 @@
+%%{
+	machine NMEA;
+	gsa_mode = ('M' @{gsa_automatic = false;} | 'A' @{gsa_automatic = true; }) comma;
+	gsa_mode_detailed = (('1' | '2' | '3' ) @{gsa_mode = GSA_MODE(fc-'0');})comma @{gsa_prn_index = 0;};
+	gsa_prn = (integer comma | zlen comma) @{if(current_digit) {gsa_prns[gsa_prn_index] = current_digit;} gsa_prn_index++; current_digit = 0; };
+	action read_gsa {
+		handler.gsa(gsa_automatic, gsa_mode, gsa_prns, gsa_pdop, gsa_hdop, gsa_vdop);
+		gsa_prn_index = 0;
+	}
+	gsa_pdop = (number comma @{ gsa_pdop = current_float; current_float = 0;}) | comma;
+	gsa_hdop = (number comma @{ gsa_hdop = current_float; current_float = 0;}) | comma;
+	gsa_vdop = (number @{ gsa_vdop = current_float; current_float = 0;})?;
+	gsa = "$GPGSA," gsa_mode gsa_mode_detailed gsa_prn{12} gsa_pdop gsa_hdop gsa_vdop checksum;
+}%%

data/parser/gsv.rl

@@ -0,0 +1,41 @@
+%%{
+	machine NMEA;
+	
+	total_gsv_number = integer comma @{total_gsv_number = current_digit; current_digit = 0;};
+
+	action allocate_gsv {
+		current_gsv_number = current_digit;
+		current_digit = 0;
+	}
+	message_number = integer comma @allocate_gsv;
+	total_satellites = integer comma @{total_satellites = current_digit; current_digit = 0;};
+
+
+	sv_prn_number = integer comma @{satellite_number = current_digit; current_digit = 0; };
+	elevation = integer comma @{elevation = current_digit; current_digit = 0;};
+	azimuth = integer comma @{azimuth = current_digit; current_digit = 0; };
+	snr_db = bcd? @{snr_db = bcd;};
+	action append_gsv {
+		SatelliteInfo satellite;
+		satellite.number = satellite_number;
+		satellite.elevation = elevation;
+		satellite.azimuth = azimuth;
+		satellite.signal_level = snr_db;
+		snr_db.nil = true;
+		satellites.push_back(satellite);
+	}
+	sv_info = sv_prn_number elevation azimuth snr_db;
+	
+	action read_gsv {
+		GSV_FLAG flag = GSV_CONTINUE;
+		if(current_gsv_number == 1) {
+			flag = GSV_START;
+		} else if(current_gsv_number == total_gsv_number) {
+			flag = GSV_END;
+		}
+		handler.gsv(flag, satellites);
+		satellites.empty();
+	}
+	gsv = "$GPGSV," total_gsv_number message_number total_satellites (sv_info comma %append_gsv)* (sv_info %append_gsv) checksum;
+}%%
+

data/parser/nmea.hpp

@@ -0,0 +1,108 @@
+#ifndef _NMEA_H_
+#define _NMEA_H_
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+#include <math.h>
+#include <stdarg.h>
+#include <vector>
+#include <string>
+#include <exception>
+
+
+namespace NMEA {
+	class Error {
+	public:
+		char buf[BUFSIZ];
+		Error(const char* msg) {
+			strncpy(buf, msg, BUFSIZ);
+		}
+	};
+	class ParseError : public Error { 
+	public:
+		ParseError(const char* msg) : Error(msg) {}
+	};
+	class DataError : public Error {
+	public:
+		DataError(const char* msg) : Error(msg) {}
+	};
+	
+	template<typename type>
+	struct Value {
+		type value;
+		bool nil;
+		Value() {
+			nil = true;
+		}
+		Value<type>& operator=(const type& rhs) {
+			nil = false;
+			value = rhs;
+			return *this;
+		}
+		Value<type>& operator=(const Value<type>& rhs) {
+			nil = rhs.nil;
+			if(!nil) {
+				value = rhs.value;
+			}
+			return *this;
+		}
+	};
+	
+	struct AngleValue {
+		int degrees;
+		double minutes;
+	};
+	
+	struct Time {
+		int year;
+		int month;
+		int day;
+		int hour;
+		int minute;
+		int second;
+		int usec;
+		Time() { flush(); }
+		void flush() { year = month = day = hour = minute = second = usec = 0; }
+	};
+	
+	typedef Value<AngleValue> Angle;
+	typedef Value<double> Double;
+	typedef Value<bool> Bool;
+	typedef Value<int> Int;
+	
+	struct SatelliteInfo {
+		Int number;
+		Int elevation;
+		Int azimuth;
+		Int signal_level;
+	};
+	
+	typedef std::vector<SatelliteInfo> satellite_list;
+	typedef Int satellite_numbers[12];
+	
+	enum GSV_FLAG {GSV_START, GSV_CONTINUE, GSV_END};
+	enum GSA_MODE {GSA_NO_FIX = 1, GSA_2D, GSA_3D};
+	enum GGA_FIX {GGA_INVALID, GGA_GPS, GGA_DGPS, GGA_PPS, GGA_RTK, GGA_FLOATRTK, GGA_ESTIMATED, GGA_MANUAL, GGA_SIMULATION};
+	enum VTG_MODE {VTG_DEFAULT, VTG_AUTONOMUS, VTG_DIFFERENTIAL, VTG_ESTIMATED, VTG_INVALID};
+	
+	class Handler {
+	public:
+		virtual void rmc(Time& time, Angle& latitude, Angle& longitude, Double& speed, Double& course, Double& magnetic_variation) = 0;
+		virtual void gsv(GSV_FLAG flag, satellite_list& satellites) = 0;
+		virtual void gsa(bool mode_automatic, GSA_MODE mode, satellite_numbers& satellites, Double& pdop, Double& hdop, Double& vdop) = 0;
+		virtual void gga(Time& time, Angle& latitude, Angle& longitude, 
+			GGA_FIX gps_quality, Int& active_satellite_count, Double& hdop, 
+			Double& altitude, Double& geoidal_height, Double& dgps_data_age, Int& dgps_station_id) = 0;
+		virtual void psrftxt(std::string& key, std::string& value) = 0;
+		virtual void vtg(Double& true_course, Double& magnetic_course, Double& knot_speed, Double& kmph_speed, VTG_MODE mode) = 0;
+		virtual void gll(Time& time, Angle& latitude, Angle& longitude) = 0;
+		virtual void bod(Double& true_degrees, Double& magnetic_degrees, std::string& to, std::string& from) = 0;
+		virtual ~Handler() {};
+	};
+	
+	bool scan(char *p, Handler& handler) throw (Error);
+}
+
+#endif /* _NMEA_H_ */

data/parser/nmea.rl

@@ -0,0 +1,155 @@
+#include "nmea.hpp"
+namespace NMEA {
+
+%%{
+	machine NMEA;
+	
+	newline = ('\r\n' | '\n' | '\r');
+	comma = ",";
+	nmea_char = [a-zA-Z0-9,_.*$: \t\-];
+	
+	action add_digit {
+		current_float = 0;
+		current_digit = current_digit*10 + (fc - '0');
+	}
+	action switch_to_float {
+		current_frac = 10;
+		current_float = current_digit;
+		current_digit = 0;
+	}
+	action add_digit_after_comma {
+		current_float += (fc - '0')*1.0 / current_frac;
+		current_frac *= 10;
+	}
+	bcd = digit @{bcd = 10*(fc - '0');} digit @{bcd += fc - '0';};
+	b3cd = bcd digit @{bcd = bcd*10 + (fc - '0');};
+	b4cd = b3cd digit @{bcd = bcd*10 + (fc - '0');};
+	integer = (digit @add_digit)+ ;
+	number = ('-' %{sign = -1;}|zlen) integer ("." @switch_to_float) (digit @add_digit_after_comma)+ %{current_float = current_float*sign; sign = 1;};
+	action add_char {
+		*current_s = fc;
+		current_s++;
+		*current_s = 0;
+	}
+	string = space* <: (nmea_char @add_char)*;
+	key_string = space* <: ((nmea_char - [:]) @add_char)+;
+	
+	utc_time = bcd @{ utc.hour = bcd; } bcd @{ utc.minute = bcd;} bcd @{ utc.second = bcd;} ("." integer %{ utc.usec = current_digit; current_digit = 0;})? comma;
+	utc_date = bcd @{ utc.day = bcd; } bcd @{ utc.month = bcd;} bcd @{ utc.year = bcd > 70 ? 1900+bcd : 2000+bcd;};
+	
+	action set_degrees {
+		current_degrees = bcd;
+		bcd = 0;
+	}
+	
+	northing = "N" | "S" @{current_degrees *= -1;};
+	action set_latitude {
+		latitude.nil = false;
+		latitude.value.degrees = current_degrees;
+		latitude.value.minutes = current_float;
+		current_float = 0;
+		current_degrees = 0;
+	}
+	latitude = (bcd @set_degrees number comma northing @set_latitude | comma) comma;
+	
+	easting = "E" | "W" @{current_degrees *= -1;};
+	action set_longitude {
+		longitude.nil = false;
+		longitude.value.degrees = current_degrees;
+		longitude.value.minutes = current_float;
+		current_degrees = 0;
+		current_float = 0;
+	}
+	longitude = (b3cd @set_degrees number comma easting @set_longitude| comma) comma;
+	
+	action sentence_begin {
+		sentence_begin = p+1;
+	}
+	action check_sum {
+		checksum[1] = fc;
+		unsigned char sum = 0, *ptr;
+		for(ptr = (unsigned char *)sentence_begin; ptr != (unsigned char*)sentence_end; ptr++) {
+			sum ^= *ptr;
+		}
+		unsigned int sum_provided;
+		sscanf(checksum, "%x", &sum_provided);
+		if(sum_provided != sum) {
+			char buf[BUFSIZ];
+			snprintf(buf, BUFSIZ, "Checksum didn't match: provided is %d, calculated is %d", sum_provided, sum);
+			throw DataError(buf);
+		}
+	}
+	checksum = '*' @{sentence_end = p; } alnum @{checksum[0] = fc;} alnum @check_sum;
+
+	include "rmc.rl";
+	include "gsv.rl";
+	include "gsa.rl";
+	include "gga.rl";
+	include "psrftxt.rl";
+	include "vtg.rl";
+	include "gll.rl";
+	include "bod.rl";
+	
+	sentence = zlen %sentence_begin rmc %read_rmc | gsv %read_gsv | gsa %read_gsa | gga %read_gga | psrftxt %read_psrftxt | vtg %read_vtg | gll %read_gll | bod %read_bod;
+	// | zda %read_zda;
+	main := sentence newline;
+}%%
+
+
+%% write data nofinal;
+
+bool scan(char *p, Handler& handler) throw (Error) {
+	char *pe;
+	int cs;
+	
+	int sign = 1;
+	int current_digit = 0, current_frac = 0;
+	double current_float = 0;
+	int current_degrees = 0;
+	int bcd = 0;
+	Time utc;
+	Angle latitude, longitude;
+	
+	char checksum[3];
+	checksum[2] = 0;
+	int sentence_len = strlen(p);
+	char current_string[sentence_len+1];
+	char *current_s = current_string;
+	char *sentence_begin = NULL, *sentence_end = NULL;
+	
+	//RMC
+	bool rmc_valid = 0;
+	Double knot_speed, course, magnetic_variation;
+	//GSV
+	satellite_list satellites;
+	Int snr_db;
+	int total_gsv_number = 0, current_gsv_number = 0, total_satellites = 0, satellite_number = 0, elevation = 0, azimuth = 0;
+	//GSA
+	bool gsa_automatic;
+	GSA_MODE gsa_mode;
+	int gsa_prn_index = 0;
+	Double gsa_pdop, gsa_hdop, gsa_vdop;
+	satellite_numbers gsa_prns;
+	//GGA
+	GGA_FIX gps_quality;
+	Int dgps_station_id, active_satellite_count;
+	Double altitude, geoidal_height, dgps_data_age;
+	char altitude_units, geoidal_height_units;
+	//PSRFTXT
+	std::string psrf_key, psrf_value;
+	//VTG
+	Double true_course, magnetic_course, vtg_knot_speed, vtg_kmph_speed;
+	VTG_MODE vtg_mode = VTG_DEFAULT;
+	//BOD
+	std::string wpt_to, wpt_from;
+	%% write init;
+	
+	pe = p + sentence_len;
+	%% write exec;
+	if(cs == NMEA_error) {
+		return false;
+	}
+	return true;
+}
+}
+

data/parser/psrftxt.rl

@@ -0,0 +1,18 @@
+%%{
+	machine NMEA;
+	action add_key {
+		psrf_key = current_string;
+		current_s = current_string; 
+		*current_s = 0;
+	}
+	psrf_key = key_string;
+	action add_value {
+		psrf_value = current_string;
+		current_s = current_string; 
+		*current_s = 0;
+	}
+	action read_psrftxt {
+		handler.psrftxt(psrf_key, psrf_value);
+	}
+	psrftxt = "$PSRFTXT," ((psrf_key %add_key ':' string %add_value )| psrf_key %add_key);
+}%%

data/parser/rmc.rl

@@ -0,0 +1,16 @@
+%%{
+	machine NMEA;
+
+
+	rmc_state = ("A" @{rmc_valid = true;} | "V" @{rmc_valid = false;}) comma;
+	knot_speed = (number comma @{knot_speed = current_float; current_float = 0;}) | (zlen comma);
+	course = (number comma @{course = current_float; current_float = 0;}) | (zlen comma);
+	magnetic_variation = (integer comma easting %{ magnetic_variation = 1.0*current_digit; current_digit = 0; }) | (number %{current_degrees = 1;} comma easting %{ magnetic_variation = current_float*current_degrees; current_float = 0; }) | comma;
+
+	action read_rmc {
+		handler.rmc(utc, latitude, longitude, knot_speed, course, magnetic_variation);
+	}
+
+	rmc = "$GPRMC," utc_time rmc_state latitude longitude knot_speed course utc_date comma magnetic_variation any*;
+	
+}%%

data/parser/vtg.rl

@@ -0,0 +1,12 @@
+%%{
+	machine NMEA;
+	true_course = (number %{true_course = current_float; current_float = 0;})? comma 'T' comma;
+	magnetic_course = (number %{magnetic_course = current_float; current_float = 0;})? comma 'M' comma;
+	vtg_knot_speed = (number %{vtg_knot_speed = current_float; current_float = 0;})? comma 'N' comma;
+	vtg_kmph_speed = (number %{vtg_kmph_speed = current_float; current_float = 0;})? comma 'K';
+	vtg_mode = (comma ('A' @{vtg_mode = VTG_AUTONOMUS;}| 'D' @{vtg_mode = VTG_DIFFERENTIAL;} | 'E' @{vtg_mode = VTG_ESTIMATED;} | 'N' @{vtg_mode = VTG_INVALID;}))?;
+	action read_vtg {
+		handler.vtg(true_course, magnetic_course, vtg_knot_speed, vtg_kmph_speed, vtg_mode);
+	}
+	vtg = "$GPVTG," true_course magnetic_course vtg_knot_speed vtg_kmph_speed vtg_mode checksum;
+}%%

data/parser/zda.rl

@@ -0,0 +1,7 @@
+%%{
+	machine NMEA;
+	action read_zda {
+		handler.zda(utc_time, zda_day, zda_month, zda_year, local_time);
+	}
+	gsa = "$GPZDA," utc_time zda_day zda_month zda_year local_time;
+}%%

data/serialport/extconf.rb

@@ -0,0 +1,13 @@
+require 'mkmf'
+
+printf("checking for OS... ")
+STDOUT.flush
+os = /-([a-z]+)/.match(RUBY_PLATFORM)[1]
+puts(os)
+$CFLAGS += " -D#{os}"
+
+if !(os == 'mswin' or os == 'bccwin')
+  exit(1) if not have_header("termios.h") or not have_header("unistd.h")
+end
+
+create_makefile("serialport")

data/serialport/serialport.c

@@ -0,0 +1,1319 @@
+/* Ruby/SerialPort $Id: serialport.c,v 1.15 2003/02/13 19:55:48 moumar Exp $
+ * Guillaume Pierronnet <moumar@netcourrier.com>
+ * Alan Stern <stern@rowland.harvard.edu>
+ *
+ * This code is hereby licensed for public consumption under either the
+ * GNU GPL v2 or greater.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * For documentation on serial programming, see the excellent:
+ * "Serial Programming Guide for POSIX Operating Systems"
+ * written Michael R. Sweet.
+ * http://www.easysw.com/~mike/serial/
+ */
+
+#define VERSION 	"0.6"
+
+#include <ruby.h>    /* ruby inclusion */
+#include <rubyio.h>  /* ruby io inclusion */
+
+struct modem_params {
+  int data_rate;
+  int data_bits;
+  int stop_bits;
+  int parity;
+  };
+
+struct line_signals {
+  int rts;
+  int dtr;
+  int cts;
+  int dsr;
+  int dcd;
+  int ri;
+  };
+
+VALUE cSerialPort; /* serial port class */
+
+static VALUE sBaud, sDataBits, sStopBits, sParity; /* strings */
+static VALUE sRts, sDtr, sCts, sDsr, sDcd, sRi;
+
+
+#if defined(mswin) || defined(bccwin)
+
+
+#include <stdio.h>   /* Standard input/output definitions */
+#include <io.h>      /* Low-level I/O definitions */
+#include <fcntl.h>   /* File control definitions */
+#include <windows.h> /* Windows standard function definitions */
+
+#define NONE            0
+#define HARD            1
+#define SOFT            2
+
+#define SPACE           SPACEPARITY
+#define MARK            MARKPARITY
+#define EVEN            EVENPARITY
+#define ODD             ODDPARITY
+
+static char sGetCommState[] = "GetCommState";
+static char sSetCommState[] = "SetCommState";
+static char sGetCommTimeouts[] = "GetCommTimeouts";
+static char sSetCommTimeouts[] = "SetCommTimeouts";
+
+
+static HANDLE sp_get_handle(obj)
+  VALUE obj;
+{
+  OpenFile *fptr;
+
+  GetOpenFile(obj, fptr);
+  return (HANDLE) _get_osfhandle(fileno(fptr->f));
+}
+
+static VALUE sp_create(class, _port)
+  VALUE class, _port;
+{
+  OpenFile *fp;
+  int fd;
+  HANDLE fh;
+  int num_port;
+  char *port;
+  char *ports[] = {
+  "COM1", "COM2", "COM3", "COM4",
+  "COM5", "COM6", "COM7", "COM8"
+  };
+  DCB dcb;
+
+  NEWOBJ(sp, struct RFile);
+  rb_secure(4);
+  OBJSETUP(sp, class, T_FILE);
+  MakeOpenFile(sp, fp);
+
+  switch(TYPE(_port)) {
+    case T_FIXNUM:
+      num_port = FIX2INT(_port);
+      if (num_port < 0 || num_port > sizeof(ports) / sizeof(ports[0]))
+	rb_raise(rb_eArgError, "illegal port number");
+      port = ports[num_port];
+      break;
+
+    case T_STRING:
+      Check_SafeStr(_port);
+      port = RSTRING(_port)->ptr;
+      break;
+
+    default:
+      rb_raise(rb_eTypeError, "wrong argument type");
+      break;
+  }
+
+  fd = open(port, O_BINARY | O_RDWR);
+  if (fd == -1)
+    rb_sys_fail(port);
+  fh = (HANDLE) _get_osfhandle(fd);
+  if (SetupComm(fh, 1024, 1024) == 0) {
+    close(fd);
+    rb_raise(rb_eArgError, "not a serial port");
+  }
+
+  dcb.DCBlength = sizeof(dcb);
+  if (GetCommState(fh, &dcb) == 0) {
+    close(fd);
+    rb_sys_fail(sGetCommState);
+  }
+  dcb.fBinary = TRUE;
+  dcb.fParity = FALSE;
+  dcb.fOutxDsrFlow = FALSE;
+  dcb.fDtrControl = DTR_CONTROL_ENABLE;
+  dcb.fDsrSensitivity = FALSE;
+  dcb.fTXContinueOnXoff = FALSE;
+  dcb.fErrorChar = FALSE;
+  dcb.fNull = FALSE;
+  dcb.fAbortOnError = FALSE;
+  dcb.XonChar = 17;
+  dcb.XoffChar = 19;
+  if (SetCommState(fh, &dcb) == 0) {
+    close(fd);
+    rb_sys_fail(sSetCommState);
+  }
+
+  fp->f = rb_fdopen(fd, "rb+");
+  fp->mode = FMODE_READWRITE | FMODE_BINMODE | FMODE_SYNC;
+  return (VALUE) sp;
+}
+
+static VALUE sp_set_modem_params(argc, argv, self)
+  int argc;
+  VALUE *argv, self;
+{
+  HANDLE fh;
+  DCB dcb;
+  VALUE _data_rate, _data_bits, _parity, _stop_bits;
+  int use_hash = 0;
+  int data_rate, data_bits, parity;
+
+  if (argc == 0)
+    return self;
+  if (argc == 1 && T_HASH == TYPE(argv[0])) {
+    use_hash = 1;
+    _data_rate = rb_hash_aref(argv[0], sBaud);
+    _data_bits = rb_hash_aref(argv[0], sDataBits);
+    _stop_bits = rb_hash_aref(argv[0], sStopBits);
+    _parity = rb_hash_aref(argv[0], sParity);
+  }
+
+  fh = sp_get_handle(self);
+  dcb.DCBlength = sizeof(dcb);
+  if (GetCommState(fh, &dcb) == 0)
+    rb_sys_fail(sGetCommState);
+
+  if (!use_hash)
+    _data_rate = argv[0];
+  if (NIL_P(_data_rate))
+    goto SkipDataRate;
+  Check_Type(_data_rate, T_FIXNUM);
+
+  data_rate = FIX2INT(_data_rate);
+  switch (data_rate) {
+    case 110:
+    case 300:
+    case 600:
+    case 1200:
+    case 2400:
+    case 4800:
+    case 9600:
+    case 14400:
+    case 19200:
+    case 38400:
+    case 56000:
+    case 57600:
+    case 115200:
+    case 128000:
+    case 256000:
+      dcb.BaudRate = data_rate;
+      break;
+
+    default:
+      rb_raise(rb_eArgError, "unknown baud rate");
+      break;
+  }
+SkipDataRate:
+
+  if (!use_hash)
+    _data_bits = (argc >= 2 ? argv[1] : INT2FIX(8));
+  if (NIL_P(_data_bits))
+    goto SkipDataBits;
+  Check_Type(_data_bits, T_FIXNUM);
+
+  data_bits = FIX2INT(_data_bits);
+  if (4 <= data_bits && data_bits <= 8)
+    dcb.ByteSize = data_bits;
+  else
+    rb_raise(rb_eArgError, "unknown character size");
+SkipDataBits:
+
+  if (!use_hash)
+    _stop_bits = (argc >= 3 ? argv[2] : INT2FIX(1));
+  if (NIL_P(_stop_bits))
+    goto SkipStopBits;
+  Check_Type(_stop_bits, T_FIXNUM);
+
+  switch (FIX2INT(_stop_bits)) {
+    case 1:
+      dcb.StopBits = ONESTOPBIT;
+      break;
+    case 2:
+      dcb.StopBits = TWOSTOPBITS;
+      break;
+    default:
+      rb_raise(rb_eArgError, "unknown number of stop bits");
+    break;
+  }
+SkipStopBits:
+
+  if (!use_hash)
+    _parity = (argc >= 4 ? argv[3] : (dcb.ByteSize == 8 ?
+      INT2FIX(NOPARITY) : INT2FIX(EVENPARITY)));
+  if (NIL_P(_parity))
+    goto SkipParity;
+  Check_Type(_parity, T_FIXNUM);
+
+  parity = FIX2INT(_parity);
+  switch (parity) {
+    case EVENPARITY:
+    case ODDPARITY:
+    case MARKPARITY:
+    case SPACEPARITY:
+    case NOPARITY:
+      dcb.Parity = parity;
+      break;
+
+    default:
+      rb_raise(rb_eArgError, "unknown parity");
+      break;
+  }
+SkipParity:
+
+  if (SetCommState(fh, &dcb) == 0)
+    rb_sys_fail(sSetCommState);
+  return self;
+}
+
+static void get_modem_params(self, mp)
+  VALUE self;
+  struct modem_params *mp;
+{
+  HANDLE fh;
+  DCB dcb;
+
+  fh = sp_get_handle(self);
+  dcb.DCBlength = sizeof(dcb);
+  if (GetCommState(fh, &dcb) == 0)
+    rb_sys_fail(sGetCommState);
+
+  mp->data_rate = dcb.BaudRate;
+  mp->data_bits = dcb.ByteSize;
+  mp->stop_bits = (dcb.StopBits == ONESTOPBIT ? 1 : 2);
+  mp->parity = dcb.Parity;
+}
+
+static VALUE sp_set_flow_control(self, val)
+  VALUE self, val;
+{
+  HANDLE fh;
+  int flowc;
+  DCB dcb;
+
+  Check_Type(val, T_FIXNUM);
+
+  fh = sp_get_handle(self);
+  dcb.DCBlength = sizeof(dcb);
+  if (GetCommState(fh, &dcb) == 0)
+    rb_sys_fail(sGetCommState);
+
+  flowc = FIX2INT(val);
+  if (flowc & HARD) {
+    dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
+    dcb.fOutxCtsFlow = TRUE;
+  } else {
+    dcb.fRtsControl = RTS_CONTROL_ENABLE;
+    dcb.fOutxCtsFlow = FALSE;
+  }
+  if (flowc & SOFT)
+    dcb.fOutX = dcb.fInX = TRUE;
+  else
+    dcb.fOutX = dcb.fInX = FALSE;
+
+  if (SetCommState(fh, &dcb) == 0)
+    rb_sys_fail(sSetCommState);
+  return self;
+}
+
+static VALUE sp_get_flow_control(self)
+  VALUE self;
+{
+  HANDLE fh;
+  int ret;
+  DCB dcb;
+
+  fh = sp_get_handle(self);
+  dcb.DCBlength = sizeof(dcb);
+  if (GetCommState(fh, &dcb) == 0)
+    rb_sys_fail(sGetCommState);
+
+  ret = 0;
+  if (dcb.fOutxCtsFlow)
+    ret += HARD;
+  if (dcb.fOutX)
+    ret += SOFT;
+
+  return INT2FIX(ret);
+}
+
+static VALUE sp_set_read_timeout(self, val)
+  VALUE self, val;
+{
+  int timeout;
+  HANDLE fh;
+  COMMTIMEOUTS ctout;
+
+  Check_Type(val, T_FIXNUM);
+  timeout = FIX2INT(val);
+
+  fh = sp_get_handle(self);
+  if (GetCommTimeouts(fh, &ctout) == 0)
+    rb_sys_fail(sGetCommTimeouts);
+
+  if (timeout < 0) {
+    ctout.ReadIntervalTimeout = MAXDWORD;
+    ctout.ReadTotalTimeoutMultiplier = 0;
+    ctout.ReadTotalTimeoutConstant = 0;
+  } else if (timeout == 0) {
+    ctout.ReadIntervalTimeout = MAXDWORD;
+    ctout.ReadTotalTimeoutMultiplier = MAXDWORD;
+    ctout.ReadTotalTimeoutConstant = MAXDWORD - 1;
+  } else {
+    ctout.ReadIntervalTimeout = timeout;
+    ctout.ReadTotalTimeoutMultiplier = 0;
+    ctout.ReadTotalTimeoutConstant = timeout;
+  }
+
+  if (SetCommTimeouts(fh, &ctout) == 0)
+    rb_sys_fail(sSetCommTimeouts);
+  return self;
+}
+
+static VALUE sp_get_read_timeout(self)
+  VALUE self;
+{
+  HANDLE fh;
+  COMMTIMEOUTS ctout;
+
+  fh = sp_get_handle(self);
+  if (GetCommTimeouts(fh, &ctout) == 0)
+    rb_sys_fail(sGetCommTimeouts);
+  switch (ctout.ReadTotalTimeoutConstant) {
+    case 0:
+      return INT2FIX(-1);
+    case MAXDWORD:
+      return INT2FIX(0);
+  }
+  return INT2FIX(ctout.ReadTotalTimeoutConstant);
+}
+
+static VALUE sp_set_write_timeout(self, val)
+  VALUE self, val;
+{
+  int timeout;
+  HANDLE fh;
+  COMMTIMEOUTS ctout;
+
+  Check_Type(val, T_FIXNUM);
+  timeout = FIX2INT(val);
+
+  fh = sp_get_handle(self);
+  if (GetCommTimeouts(fh, &ctout) == 0)
+    rb_sys_fail(sGetCommTimeouts);
+
+  if (timeout <= 0) {
+    ctout.WriteTotalTimeoutMultiplier = 0;
+    ctout.WriteTotalTimeoutConstant = 0;
+  } else {
+    ctout.WriteTotalTimeoutMultiplier = timeout;
+    ctout.WriteTotalTimeoutConstant = 0;
+  }
+
+  if (SetCommTimeouts(fh, &ctout) == 0)
+    rb_sys_fail(sSetCommTimeouts);
+  return self;
+}
+
+static VALUE sp_get_write_timeout(self)
+  VALUE self;
+{
+  HANDLE fh;
+  COMMTIMEOUTS ctout;
+
+  fh = sp_get_handle(self);
+  if (GetCommTimeouts(fh, &ctout) == 0)
+    rb_sys_fail(sGetCommTimeouts);
+  return INT2FIX(ctout.WriteTotalTimeoutMultiplier);
+}
+
+static void delay_ms(time)
+  int time;
+{
+  HANDLE ev;
+
+  ev = CreateEvent(NULL, FALSE, FALSE, NULL);
+  if (!ev)
+    rb_sys_fail("CreateEvent");
+  if (WaitForSingleObject(ev, time) == WAIT_FAILED)
+    rb_sys_fail("WaitForSingleObject");
+  CloseHandle(ev);
+}
+
+static VALUE sp_break(self, time)
+  VALUE self, time;
+{
+  HANDLE fh;
+
+  Check_Type(time, T_FIXNUM);
+
+  fh = sp_get_handle(self);
+  if (SetCommBreak(fh) == 0)
+    rb_sys_fail("SetCommBreak");
+  delay_ms(FIX2INT(time) * 100);
+  ClearCommBreak(fh);
+  return Qnil;
+}
+
+static void get_line_signals(obj, ls)
+  VALUE obj;
+  struct line_signals *ls;
+{
+  HANDLE fh;
+  int status;
+
+  fh = sp_get_handle(obj);
+  if (GetCommModemStatus(fh, &status) == 0)
+    rb_sys_fail("GetCommModemStatus");
+
+  ls->cts = (status & MS_CTS_ON ? 1 : 0);
+  ls->dsr = (status & MS_DSR_ON ? 1 : 0);
+  ls->dcd = (status & MS_RLSD_ON ? 1 : 0);
+  ls->ri = (status & MS_RING_ON ? 1 : 0);
+}
+
+static VALUE set_signal(obj, val, sigoff, sigon)
+  VALUE obj,val;
+  int sigoff, sigon;
+{
+  HANDLE fh;
+  int set, sig;
+
+  Check_Type(val, T_FIXNUM);
+  fh = sp_get_handle(obj);
+
+  set = FIX2INT(val);
+  if (set == 0)
+    sig = sigoff;
+  else if (set == 1)
+    sig = sigon;
+  else
+    rb_raise(rb_eArgError, "invalid value");
+
+  if (EscapeCommFunction(fh, sig) == 0)
+    rb_sys_fail("EscapeCommFunction");
+  return obj;
+}
+
+static VALUE sp_set_rts(self, val)
+  VALUE self, val;
+{
+  return set_signal(self, val, CLRRTS, SETRTS);
+}
+
+static VALUE sp_set_dtr(self, val)
+  VALUE self, val;
+{
+  return set_signal(self, val, CLRDTR, SETDTR);
+}
+
+static VALUE sp_get_rts(self)
+  VALUE self;
+{
+  rb_notimplement();
+  return self;
+}
+
+static VALUE sp_get_dtr(self)
+  VALUE self;
+{
+  rb_notimplement();
+  return self;
+}
+
+
+#else /* defined(mswin) || defined(bccwin) */
+
+
+#include <stdio.h>   /* Standard input/output definitions */
+#include <unistd.h>  /* UNIX standard function definitions */
+#include <fcntl.h>   /* File control definitions */
+#include <errno.h>   /* Error number definitions */
+#include <termios.h> /* POSIX terminal control definitions */
+#include <sys/ioctl.h>
+
+#ifdef CRTSCTS
+#define HAVE_FLOWCONTROL_HARD 1
+#else
+#undef HAVE_FLOWCONTROL_HARD
+#endif
+
+#define NONE            0
+#define HARD            1
+#define SOFT            2
+
+#define SPACE           0
+#define MARK            0
+#define EVEN            1
+#define ODD             2
+
+static char sTcgetattr[] = "tcgetattr";
+static char sTcsetattr[] = "tcsetattr";
+static char sIoctl[] = "ioctl";
+
+
+static int sp_get_fd(obj)
+  VALUE obj;
+{
+  OpenFile *fptr;
+
+  GetOpenFile(obj, fptr);
+  return (fileno(fptr->f));
+}
+
+static VALUE sp_create(class, _port)
+  VALUE class, _port;
+{
+  OpenFile *fp;
+  int fd;
+  int num_port;
+  char *port;
+  char *ports[] = {
+#if defined(linux) || defined(cygwin)
+  "/dev/ttyS0", "/dev/ttyS1", "/dev/ttyS2", "/dev/ttyS3",
+  "/dev/ttyS4", "/dev/ttyS5", "/dev/ttyS6", "/dev/ttyS7"
+#elif defined(freebsd) || defined(netbsd) || defined(openbsd)
+  "/dev/cuaa0", "/dev/cuaa1", "/dev/cuaa2", "/dev/cuaa3",
+  "/dev/cuaa4", "/dev/cuaa5", "/dev/cuaa6", "/dev/cuaa7"
+#elif defined(solaris)
+  "/dev/ttya", "/dev/ttyb", "/dev/ttyc", "/dev/ttyd",
+  "/dev/ttye", "/dev/ttyf", "/dev/ttyg", "/dev/ttyh"
+#elif defined(aix)
+  "/dev/tty0", "/dev/tty1", "/dev/tty2", "/dev/tty3",
+  "/dev/tty4", "/dev/tty5", "/dev/tty6", "/dev/tty7"
+#elif defined(irix)
+  "/dev/ttyf1", "/dev/ttyf2", "/dev/ttyf3", "/dev/ttyf4",
+  "/dev/ttyf5", "/dev/ttyf6", "/dev/ttyf7", "/dev/ttyf8"
+#endif
+  };
+  struct termios params;
+
+  NEWOBJ(sp, struct RFile);
+  rb_secure(4);
+  OBJSETUP(sp, class, T_FILE);
+  MakeOpenFile(sp, fp);
+
+  switch(TYPE(_port)) {
+    case T_FIXNUM:
+      num_port = FIX2INT(_port);
+      if (num_port < 0 || num_port > sizeof(ports) / sizeof(ports[0]))
+	rb_raise(rb_eArgError, "illegal port number");
+      port = ports[num_port];
+      break;
+
+    case T_STRING:
+      Check_SafeStr(_port);
+      port = RSTRING(_port)->ptr;
+      break;
+
+    default:
+      rb_raise(rb_eTypeError, "wrong argument type");
+      break;
+  }
+
+  fd = open(port, O_RDWR | O_NOCTTY | O_NDELAY);
+  if (fd == -1)
+    rb_sys_fail(port);
+  if (!isatty(fd)) {
+    close(fd);
+    rb_raise(rb_eArgError, "not a serial port");
+  }
+
+  /* enable blocking read */
+  fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) & ~O_NONBLOCK);
+
+  if (tcgetattr(fd, &params) == -1) {
+    close(fd);
+    rb_sys_fail(sTcgetattr);
+  }
+  params.c_oflag = 0;
+  params.c_lflag = 0;
+  params.c_iflag &= (IXON | IXOFF | IXANY);
+  params.c_cflag |= CLOCAL | CREAD;
+  params.c_cflag &= ~HUPCL;
+  if (tcsetattr(fd, TCSANOW, &params) == -1) {
+    close(fd);
+    rb_sys_fail(sTcsetattr);
+  }
+
+  fp->f = rb_fdopen(fd, "r+");
+  fp->mode = FMODE_READWRITE | FMODE_SYNC;
+  return (VALUE) sp;
+}
+
+static VALUE sp_set_modem_params(argc, argv, self)
+  int argc;
+  VALUE *argv, self;
+{
+  int fd;
+  struct termios params;
+  VALUE _data_rate, _data_bits, _parity, _stop_bits;
+  int use_hash = 0;
+  int data_rate, data_bits;
+
+  if (argc == 0)
+    return self;
+  if (argc == 1 && T_HASH == TYPE(argv[0])) {
+    use_hash = 1;
+    _data_rate = rb_hash_aref(argv[0], sBaud);
+    _data_bits = rb_hash_aref(argv[0], sDataBits);
+    _stop_bits = rb_hash_aref(argv[0], sStopBits);
+    _parity = rb_hash_aref(argv[0], sParity);
+  }
+
+  fd = sp_get_fd(self);
+  if (tcgetattr(fd, &params) == -1)
+    rb_sys_fail(sTcgetattr);
+
+  if (!use_hash)
+    _data_rate = argv[0];
+  if (NIL_P(_data_rate))
+    goto SkipDataRate;
+  Check_Type(_data_rate, T_FIXNUM);
+
+  switch(FIX2INT(_data_rate)) {
+    case 50:    data_rate = B50; break;
+    case 75:    data_rate = B75; break;
+    case 110:   data_rate = B110; break;
+    case 134:   data_rate = B134; break;
+    case 150:   data_rate = B150; break;
+    case 200:   data_rate = B200; break;
+    case 300:   data_rate = B300; break;
+    case 600:   data_rate = B600; break;
+    case 1200:  data_rate = B1200; break;
+    case 1800:  data_rate = B1800; break;
+    case 2400:  data_rate = B2400; break;
+    case 4800:  data_rate = B4800; break;
+    case 9600:  data_rate = B9600; break;
+    case 19200: data_rate = B19200; break;
+    case 38400: data_rate = B38400; break;
+#ifdef B57600
+    case 57600: data_rate = B57600; break;
+#endif
+#ifdef B76800
+    case 76800: data_rate = B76800; break;
+#endif
+#ifdef B115200
+    case 115200: data_rate = B115200; break;
+#endif
+#ifdef B230400
+    case 230400: data_rate = B230400; break;
+#endif
+
+    default:
+      rb_raise(rb_eArgError, "unknown baud rate");
+      break;
+  }
+  cfsetispeed(&params, data_rate);
+  cfsetospeed(&params, data_rate);
+SkipDataRate:
+
+  if (!use_hash)
+    _data_bits = (argc >= 2 ? argv[1] : INT2FIX(8));
+  if (NIL_P(_data_bits))
+    goto SkipDataBits;
+  Check_Type(_data_bits, T_FIXNUM);
+
+  switch(FIX2INT(_data_bits)) {
+    case 5:
+      data_bits = CS5;
+      break;
+    case 6:
+      data_bits = CS6;
+      break;
+    case 7:
+      data_bits = CS7;
+      break;
+    case 8:
+      data_bits = CS8;
+      break;
+    default:
+      rb_raise(rb_eArgError, "unknown character size");
+      break;
+  }
+  params.c_cflag &= ~CSIZE;
+  params.c_cflag |= data_bits;
+SkipDataBits:
+
+  if (!use_hash)
+    _stop_bits = (argc >= 3 ? argv[2] : INT2FIX(1));
+  if (NIL_P(_stop_bits))
+    goto SkipStopBits;
+  Check_Type(_stop_bits, T_FIXNUM);
+
+  switch(FIX2INT(_stop_bits)) {
+    case 1:
+      params.c_cflag &= ~CSTOPB;
+      break;
+    case 2:
+      params.c_cflag |= CSTOPB;
+      break;
+    default:
+      rb_raise(rb_eArgError, "unknown number of stop bits");
+    break;
+  }
+SkipStopBits:
+
+  if (!use_hash)
+    _parity = (argc >= 4 ? argv[3] : ((params.c_cflag & CSIZE) == CS8 ?
+      INT2FIX(NONE) : INT2FIX(EVEN)));
+  if (NIL_P(_parity))
+    goto SkipParity;
+  Check_Type(_parity, T_FIXNUM);
+
+  switch(FIX2INT(_parity)) {
+    case EVEN:
+      params.c_cflag |= PARENB;
+      params.c_cflag &= ~PARODD;
+      break;
+
+    case ODD:
+      params.c_cflag |= PARENB;
+      params.c_cflag |= PARODD;
+      break;
+
+    case NONE:
+      params.c_cflag &= ~PARENB;
+      break;
+
+    default:
+      rb_raise(rb_eArgError, "unknown parity");
+      break;
+  }
+SkipParity:
+
+  if (tcsetattr(fd, TCSANOW, &params) == -1)
+    rb_sys_fail(sTcsetattr);
+  return self;
+}
+
+static void get_modem_params(self, mp)
+  VALUE self;
+  struct modem_params *mp;
+{
+  int fd;
+  struct termios params;
+
+  fd = sp_get_fd(self);
+  if (tcgetattr(fd, &params) == -1)
+    rb_sys_fail(sTcgetattr);
+
+  switch (cfgetospeed(&params)) {
+    case B50:    mp->data_rate = 50; break;
+    case B75:    mp->data_rate = 75; break;
+    case B110:   mp->data_rate = 110; break;
+    case B134:   mp->data_rate = 134; break;
+    case B150:   mp->data_rate = 150; break;
+    case B200:   mp->data_rate = 200; break;
+    case B300:   mp->data_rate = 300; break;
+    case B600:   mp->data_rate = 600; break;
+    case B1200:  mp->data_rate = 1200; break;
+    case B1800:  mp->data_rate = 1800; break;
+    case B2400:  mp->data_rate = 2400; break;
+    case B4800:  mp->data_rate = 4800; break;
+    case B9600:  mp->data_rate = 9600; break;
+    case B19200: mp->data_rate = 19200; break;
+    case B38400: mp->data_rate = 38400; break;
+#ifdef B57600
+    case B57600: mp->data_rate = 57600; break;
+#endif
+#ifdef B76800
+    case B76800: mp->data_rate = 76800; break;
+#endif
+#ifdef B115200
+    case B115200: mp->data_rate = 115200; break;
+#endif
+#ifdef B230400
+    case B230400: mp->data_rate = 230400; break;
+#endif
+  }
+
+  switch(params.c_cflag & CSIZE) {
+    case CS5:
+      mp->data_bits = 5;
+      break;
+    case CS6:
+      mp->data_bits = 6;
+      break;
+    case CS7:
+      mp->data_bits = 7;
+      break;
+    case CS8:
+      mp->data_bits = 8;
+      break;
+    default:
+      mp->data_bits = 0;
+      break;
+  }
+
+  mp->stop_bits = (params.c_cflag & CSTOPB ? 2 : 1);
+
+  if (!(params.c_cflag & PARENB))
+    mp->parity = NONE;
+  else if (params.c_cflag & PARODD)
+    mp->parity = ODD;
+  else
+    mp->parity = EVEN;
+}
+
+static VALUE sp_set_flow_control(self, val)
+  VALUE self, val;
+{
+  int fd;
+  int flowc;
+  struct termios params;
+
+  Check_Type(val, T_FIXNUM);
+
+  fd = sp_get_fd(self);
+  if (tcgetattr(fd, &params) == -1)
+    rb_sys_fail(sTcgetattr);
+
+  flowc = FIX2INT(val);
+  if (flowc & HARD)
+#ifdef HAVE_FLOWCONTROL_HARD
+    params.c_cflag |= CRTSCTS;
+  else
+    params.c_cflag &= ~CRTSCTS;
+#else
+    rb_raise(rb_eIOError, "Hardware flow control not supported");
+#endif
+  if (flowc & SOFT)
+    params.c_iflag |= (IXON | IXOFF | IXANY);
+  else
+    params.c_iflag &= ~(IXON | IXOFF | IXANY);
+
+  if (tcsetattr(fd, TCSANOW, &params) == -1)
+    rb_sys_fail(sTcsetattr);
+  return self;
+}
+
+static VALUE sp_get_flow_control(self)
+  VALUE self;
+{
+  int ret;
+  int fd;
+  struct termios params;
+
+  fd = sp_get_fd(self);
+  if (tcgetattr(fd, &params) == -1)
+    rb_sys_fail(sTcgetattr);
+
+  ret = 0;
+#ifdef HAVE_FLOWCONTROL_HARD
+  if (params.c_cflag & CRTSCTS)
+    ret += HARD;
+#endif
+  if (params.c_iflag & (IXON | IXOFF | IXANY))
+    ret += SOFT;
+
+  return INT2FIX(ret);
+}
+
+static VALUE sp_set_read_timeout(self, val)
+  VALUE self, val;
+{
+  int timeout;
+  int fd;
+  struct termios params;
+
+  Check_Type(val, T_FIXNUM);
+  timeout = FIX2INT(val);
+
+  fd = sp_get_fd(self);
+  if (tcgetattr(fd, &params) == -1)
+    rb_sys_fail(sTcgetattr);
+
+  if (timeout < 0) {
+    params.c_cc[VTIME] = 0;
+    params.c_cc[VMIN] = 0;
+  } else if (timeout == 0) {
+    params.c_cc[VTIME] = 0;
+    params.c_cc[VMIN] = 1;
+  } else {
+    params.c_cc[VTIME] = (timeout + 50) / 100;
+    params.c_cc[VMIN] = 0;
+  }
+
+  if (tcsetattr(fd, TCSANOW, &params) == -1)
+    rb_sys_fail(sTcsetattr);
+  return self;
+}
+
+static VALUE sp_get_read_timeout(self)
+  VALUE self;
+{
+  int fd;
+  struct termios params;
+
+  fd = sp_get_fd(self);
+  if (tcgetattr(fd, &params) == -1)
+    rb_sys_fail(sTcgetattr);
+  if (params.c_cc[VTIME] == 0 && params.c_cc[VMIN] == 0)
+    return INT2FIX(-1);
+  return INT2FIX(params.c_cc[VTIME] * 100);
+}
+
+static VALUE sp_set_write_timeout(self, val)
+  VALUE self, val;
+{
+  rb_notimplement();
+  return self;
+}
+
+static VALUE sp_get_write_timeout(self)
+  VALUE self;
+{
+  rb_notimplement();
+  return self;
+}
+
+static VALUE sp_break(self, time)
+  VALUE self, time;
+{
+  int fd;
+
+  Check_Type(time, T_FIXNUM);
+
+  fd = sp_get_fd(self);
+  if (tcsendbreak(fd, FIX2INT(time) / 3) == -1)
+    rb_sys_fail("tcsendbreak");
+  return Qnil;
+}
+
+static void get_line_signals(obj, ls)
+  VALUE obj;
+  struct line_signals *ls;
+{
+  int fd, status;
+
+  fd = sp_get_fd(obj);
+  if (ioctl(fd, TIOCMGET, &status) == -1)
+    rb_sys_fail(sIoctl);
+
+  ls->rts = (status & TIOCM_RTS ? 1 : 0);
+  ls->dtr = (status & TIOCM_DTR ? 1 : 0);
+  ls->cts = (status & TIOCM_CTS ? 1 : 0);
+  ls->dsr = (status & TIOCM_DSR ? 1 : 0);
+  ls->dcd = (status & TIOCM_CD ? 1 : 0);
+  ls->ri = (status & TIOCM_RI ? 1 : 0);
+}
+
+static VALUE set_signal(obj, val, sig)
+  VALUE obj,val;
+  int sig;
+{
+  int status;
+  int fd;
+  int set;
+
+  Check_Type(val, T_FIXNUM);
+  fd = sp_get_fd(obj);
+  if (ioctl(fd, TIOCMGET, &status) == -1)
+    rb_sys_fail(sIoctl);
+
+  set = FIX2INT(val);
+  if (set == 0)
+    status &= ~sig;
+  else if (set == 1)
+    status |= sig;
+  else
+    rb_raise(rb_eArgError, "invalid value");
+
+  if (ioctl(fd, TIOCMSET, &status) == -1)
+    rb_sys_fail(sIoctl);
+  return obj;
+}
+
+static VALUE sp_set_rts(self, val)
+  VALUE self, val;
+{
+    return set_signal(self, val, TIOCM_RTS);
+}
+
+static VALUE sp_set_dtr(self, val)
+  VALUE self, val;
+{
+  return set_signal(self, val, TIOCM_DTR);
+}
+
+static VALUE sp_get_rts(self)
+  VALUE self;
+{
+  struct line_signals ls;
+
+  get_line_signals(self, &ls);
+  return INT2FIX(ls.rts);
+}
+
+static VALUE sp_get_dtr(self)
+  VALUE self;
+{
+  struct line_signals ls;
+
+  get_line_signals(self, &ls);
+  return INT2FIX(ls.dtr);
+}
+
+
+#endif /* defined(mswin) || defined(bccwin) */
+
+
+static VALUE sp_set_data_rate(self, data_rate)
+  VALUE self, data_rate;
+{
+  VALUE argv[4];
+
+  argv[0] = data_rate;
+  argv[1] = argv[2] = argv[3] = Qnil;
+  return sp_set_modem_params(4, argv, self);
+}
+
+static VALUE sp_set_data_bits(self, data_bits)
+  VALUE self, data_bits;
+{
+  VALUE argv[4];
+
+  argv[1] = data_bits;
+  argv[0] = argv[2] = argv[3] = Qnil;
+  return sp_set_modem_params(4, argv, self);
+}
+
+static VALUE sp_set_stop_bits(self, stop_bits)
+  VALUE self, stop_bits;
+{
+  VALUE argv[4];
+
+  argv[2] = stop_bits;
+  argv[0] = argv[1] = argv[3] = Qnil;
+  return sp_set_modem_params(4, argv, self);
+}
+
+static VALUE sp_set_parity(self, parity)
+  VALUE self, parity;
+{
+  VALUE argv[4];
+
+  argv[3] = parity;
+  argv[0] = argv[1] = argv[2] = Qnil;
+  return sp_set_modem_params(4, argv, self);
+}
+
+static VALUE sp_get_data_rate(self)
+  VALUE self;
+{
+  struct modem_params mp;
+
+  get_modem_params(self, &mp);
+  return INT2FIX(mp.data_rate);
+}
+
+static VALUE sp_get_data_bits(self)
+  VALUE self;
+{
+  struct modem_params mp;
+
+  get_modem_params(self, &mp);
+  return INT2FIX(mp.data_bits);
+}
+
+static VALUE sp_get_stop_bits(self)
+  VALUE self;
+{
+  struct modem_params mp;
+
+  get_modem_params(self, &mp);
+  return INT2FIX(mp.stop_bits);
+}
+
+static VALUE sp_get_parity(self)
+  VALUE self;
+{
+  struct modem_params mp;
+
+  get_modem_params(self, &mp);
+  return INT2FIX(mp.parity);
+}
+
+static VALUE sp_get_modem_params(self)
+  VALUE self;
+{
+  struct modem_params mp;
+  VALUE hash;
+
+  get_modem_params(self, &mp);
+  hash = rb_hash_new();
+  rb_hash_aset(hash, sBaud, INT2FIX(mp.data_rate));
+  rb_hash_aset(hash, sDataBits, INT2FIX(mp.data_bits));
+  rb_hash_aset(hash, sStopBits, INT2FIX(mp.stop_bits));
+  rb_hash_aset(hash, sParity, INT2FIX(mp.parity));
+  return hash;
+}
+
+static VALUE sp_get_cts(self)
+  VALUE self;
+{
+  struct line_signals ls;
+
+  get_line_signals(self, &ls);
+  return INT2FIX(ls.cts);
+}
+
+static VALUE sp_get_dsr(self)
+  VALUE self;
+{
+  struct line_signals ls;
+
+  get_line_signals(self, &ls);
+  return INT2FIX(ls.dsr);
+}
+
+static VALUE sp_get_dcd(self)
+  VALUE self;
+{
+  struct line_signals ls;
+
+  get_line_signals(self, &ls);
+  return INT2FIX(ls.dcd);
+}
+
+static VALUE sp_get_ri(self)
+  VALUE self;
+{
+  struct line_signals ls;
+
+  get_line_signals(self, &ls);
+  return INT2FIX(ls.ri);
+}
+
+static VALUE
+sp_signals(self)
+  VALUE self;
+{
+  struct line_signals ls;
+  VALUE hash;
+
+  get_line_signals(self, &ls);
+  hash = rb_hash_new();
+#if !(defined(mswin) || defined(bccwin))
+  rb_hash_aset(hash, sRts, INT2FIX(ls.rts));
+  rb_hash_aset(hash, sDtr, INT2FIX(ls.dtr));
+#endif
+  rb_hash_aset(hash, sCts, INT2FIX(ls.cts));
+  rb_hash_aset(hash, sDsr, INT2FIX(ls.dsr));
+  rb_hash_aset(hash, sDcd, INT2FIX(ls.dcd));
+  rb_hash_aset(hash, sRi, INT2FIX(ls.ri));
+  return hash;
+}
+
+void Init_serialport() {
+	VALUE code;
+	VALUE lineno = INT2NUM(1);
+	VALUE filename = rb_str_new2(__FILE__);
+	VALUE argv[3] = {code, filename lineno};
+	
+  sBaud = rb_str_new2("baud");
+  sDataBits = rb_str_new2("data_bits");
+  sStopBits = rb_str_new2("stop_bits");
+  sParity = rb_str_new2("parity");
+  sRts = rb_str_new2("rts");
+  sDtr = rb_str_new2("dtr");
+  sCts = rb_str_new2("cts");
+  sDsr = rb_str_new2("dsr");
+  sDcd = rb_str_new2("dcd");
+  sRi = rb_str_new2("ri");
+
+  rb_gc_register_address(&sBaud);
+  rb_gc_register_address(&sDataBits);
+  rb_gc_register_address(&sStopBits);
+  rb_gc_register_address(&sParity);
+  rb_gc_register_address(&sRts);
+  rb_gc_register_address(&sDtr);
+  rb_gc_register_address(&sCts);
+  rb_gc_register_address(&sDsr);
+  rb_gc_register_address(&sDcd);
+  rb_gc_register_address(&sRi);
+
+  cSerialPort = rb_define_class("SerialPort", rb_cIO);
+  rb_define_singleton_method(cSerialPort, "create", sp_create, 1);
+
+  rb_define_method(cSerialPort, "get_modem_params", sp_get_modem_params, 0);
+  rb_define_method(cSerialPort, "set_modem_params", sp_set_modem_params, -1);
+  rb_define_method(cSerialPort, "modem_params", sp_get_modem_params, 0);
+  rb_define_method(cSerialPort, "modem_params=", sp_set_modem_params, -1);
+  rb_define_method(cSerialPort, "baud", sp_get_data_rate, 0);
+  rb_define_method(cSerialPort, "baud=", sp_set_data_rate, 1);
+  rb_define_method(cSerialPort, "data_bits", sp_get_data_bits, 0);
+  rb_define_method(cSerialPort, "data_bits=", sp_set_data_bits, 1);
+  rb_define_method(cSerialPort, "stop_bits", sp_get_stop_bits, 0);
+  rb_define_method(cSerialPort, "stop_bits=", sp_set_stop_bits, 1);
+  rb_define_method(cSerialPort, "parity", sp_get_parity, 0);
+  rb_define_method(cSerialPort, "parity=", sp_set_parity, 1);
+
+  rb_define_method(cSerialPort, "flow_control=", sp_set_flow_control, 1);
+  rb_define_method(cSerialPort, "flow_control", sp_get_flow_control, 0);
+
+  rb_define_method(cSerialPort, "read_timeout", sp_get_read_timeout, 0);
+  rb_define_method(cSerialPort, "read_timeout=", sp_set_read_timeout, 1);
+  rb_define_method(cSerialPort, "write_timeout", sp_get_write_timeout, 0);
+  rb_define_method(cSerialPort, "write_timeout=", sp_set_write_timeout, 1);
+
+  rb_define_method(cSerialPort, "break", sp_break, 1);
+
+  rb_define_method(cSerialPort, "signals", sp_signals, 0);
+  rb_define_method(cSerialPort, "get_signals", sp_signals, 0);
+  rb_define_method(cSerialPort, "rts", sp_get_rts, 0);
+  rb_define_method(cSerialPort, "rts=", sp_set_rts, 1);
+  rb_define_method(cSerialPort, "dtr", sp_get_dtr, 0);
+  rb_define_method(cSerialPort, "dtr=", sp_set_dtr, 1);
+  rb_define_method(cSerialPort, "cts", sp_get_cts, 0);
+  rb_define_method(cSerialPort, "dsr", sp_get_dsr, 0);
+  rb_define_method(cSerialPort, "dcd", sp_get_dcd, 0);
+  rb_define_method(cSerialPort, "ri", sp_get_ri, 0);
+
+  rb_define_const(cSerialPort, "NONE", INT2FIX(NONE));
+  rb_define_const(cSerialPort, "HARD", INT2FIX(HARD));
+  rb_define_const(cSerialPort, "SOFT", INT2FIX(SOFT));
+
+  rb_define_const(cSerialPort, "SPACE", INT2FIX(SPACE));
+  rb_define_const(cSerialPort, "MARK", INT2FIX(MARK));
+  rb_define_const(cSerialPort, "EVEN", INT2FIX(EVEN));
+  rb_define_const(cSerialPort, "ODD", INT2FIX(ODD));
+
+  rb_define_const(cSerialPort, "VERSION", rb_str_new2(VERSION));
+
+  /* The following definitions are more easily carried out in Ruby */
+  //rb_eval_string(
+  lineno = INT2NUM(__LINE__ + 1)
+	code = rb_str_new2("class SerialPort\n"
+
+	  "private_class_method(:create)\n"
+
+	  "def SerialPort::new(port, *params)\n"
+	    "sp = create(port)\n"
+	    "begin\n"
+	      "sp.set_modem_params(*params)\n"
+	    "rescue\n"
+	      "sp.close\n"
+	      "raise\n"
+	    "end\n"
+	    "return sp\n"
+	  "end\n"
+
+	  "def SerialPort::open(port, *params)\n"
+	    "sp = create(port)\n"
+	    "begin\n"
+	      "sp.set_modem_params(*params)\n"
+	      "if (block_given?)\n"
+		"yield sp\n"
+		"sp.close\n"
+		"return nil\n"
+	      "end\n"
+	    "rescue\n"
+	      "sp.close\n"
+	      "raise\n"
+	    "end\n"
+	    "return sp\n"
+	  "end\n"
+
+	"end\n"
+  );
+	rb_obj_instance_eval(sizeof(argv), argv, rb_mKernel);
+}