Term-Slang-0.07/0040755000076500007650000000000007076425434012714 5ustar danieldanielTerm-Slang-0.07/typemap0100644000076500007650000000174507023512734014312 0ustar danieldanielTYPEMAP SLsmg_Term_Type * T_PTROBJ Scroll_Line_Type * O_OBJECT SLscroll_Window_Type * T_PTROBJ # SLscroll_Type * T_PTROBJ SLang_Read_Line_Type * T_PTROBJ SLang_RLine_Info_Type * T_PTROBJ int * T_IV unsigned short * T_UV ###################################################################### OUTPUT # The Perl object is blessed into 'CLASS', which should be a # char* having the name of the package for the blessing. O_OBJECT sv_setref_pv( $arg, CLASS, (void*)$var ); T_OBJECT sv_setref_pv( $arg, Nullch, (void*)$var ); ###################################################################### INPUT O_OBJECT if( sv_isobject($arg) && (SvTYPE(SvRV($arg)) == SVt_PVMG) ) $var = ($type)SvIV((SV*)SvRV( $arg )); else{ warn( \"${Package}::$func_name() -- $var is not a blessed SV reference\" ); XSRETURN_UNDEF; } T_OBJECT if( SvROK($arg) ) $var = ($type)SvIV((SV*)SvRV( $arg )); else{ warn( \"${Package}::$func_name() -- $var is not an SV reference\" ); XSRETURN_UNDEF; } Term-Slang-0.07/Slang.pm0100644000076500007650000001065607076425331014317 0ustar danieldanielpackage Term::Slang; # $Id: Slang.pm,v 1.9 2000/04/16 21:04:25 daniel Exp $ use strict; use Exporter; use vars qw($VERSION @ISA @EXPORT_OK %EXPORT_TAGS); $VERSION = '0.07'; @ISA = qw(Exporter); @EXPORT_OK = qw( SLang_buffer_keystring SLang_flush_input SLang_getkey SLang_getkey_intr_hook SLang_init_readline SLang_init_tty SLang_input_pending SLang_read_line SLang_reset_tty SLang_rline_insert SLang_rline_save_line SLang_ungetkey SLang_ungetkey_string SLkp_define_keysym SLkp_getkey SLkp_init SLrline_redraw SLscroll_create SLscroll_find_line_num SLscroll_find_top SLscroll_next_n SLscroll_pagedown SLscroll_pageup SLscroll_prev_n SLline_next SLline_prev SLline_data SLline_create SLscroll_window_current_line SLscroll_window_lines SLscroll_window_top_line SLscroll_window_line_num SLscroll_window_num_lines SLscroll_window_nrows SLsig_block_signals SLsig_unblock_signals SLsmg_char_at SLsmg_cls SLsmg_draw_box SLsmg_draw_hline SLsmg_draw_object SLsmg_draw_vline SLsmg_erase_eol SLsmg_erase_eos SLsmg_fill_region SLsmg_forward SLsmg_get_column SLsmg_get_row SLsmg_gotorc SLsmg_init_smg SLsmg_normal_video SLsmg_printf SLsmg_read_raw SLsmg_refresh SLsmg_reset_smg SLsmg_resume_smg SLsmg_reverse_video SLsmg_set_char_set SLsmg_set_color SLsmg_set_color_in_region SLsmg_set_screen_start SLsmg_set_terminal_info SLsmg_suspend_smg SLsmg_touch_lines SLsmg_write_char SLsmg_write_color_chars SLsmg_write_nchars SLsmg_write_nstring SLsmg_write_raw SLsmg_write_string SLsmg_write_wrapped_string SLsmg_reinit_smg SLtt_beep SLtt_begin_insert SLtt_bold_video SLtt_cls SLtt_del_eol SLtt_delete_char SLtt_delete_nlines SLtt_end_insert SLtt_erase_line SLtt_flush_output SLtt_get_screen_size SLtt_get_terminfo SLtt_goto_rc SLtt_init_video SLtt_normal_video SLtt_putchar SLtt_reset_scroll_region SLtt_reset_video SLtt_reverse_index SLtt_reverse_video SLtt_set_color SLtt_set_cursor_visibility SLtt_set_mouse_mode SLtt_set_scroll_region SLtt_smart_puts SLtt_write_string SLtt_set_mono SLtty_set_suspend_state SLANG_GETKEY_ERROR SLANG_VERSION SLSMG_CKBRD_CHAR SLSMG_COLOR_BLACK SLSMG_COLOR_BLUE SLSMG_COLOR_BRIGHT_BLUE SLSMG_COLOR_BRIGHT_BROWN SLSMG_COLOR_BRIGHT_CYAN SLSMG_COLOR_BRIGHT_GREEN SLSMG_COLOR_BRIGHT_MAGENTA SLSMG_COLOR_BRIGHT_RED SLSMG_COLOR_BRIGHT_WHITE SLSMG_COLOR_BROWN SLSMG_COLOR_CYAN SLSMG_COLOR_GRAY SLSMG_COLOR_GREEN SLSMG_COLOR_LGRAY SLSMG_COLOR_MAGENTA SLSMG_COLOR_RED SLSMG_DTEE_CHAR SLSMG_HLINE_CHAR SLSMG_LLCORN_CHAR SLSMG_LRCORN_CHAR SLSMG_LTEE_CHAR SLSMG_NEWLINE_IGNORED SLSMG_NEWLINE_MOVES SLSMG_NEWLINE_PRINTABLE SLSMG_NEWLINE_SCROLLS SLSMG_PLUS_CHAR SLSMG_RTEE_CHAR SLSMG_ULCORN_CHAR SLSMG_URCORN_CHAR SLSMG_UTEE_CHAR SLSMG_VLINE_CHAR SLTT_ALTC_MASK SLTT_BLINK_MASK SLTT_BOLD_MASK SLTT_REV_MASK SLTT_ULINE_MASK SL_KEY_A1 SL_KEY_A3 SL_KEY_B2 SL_KEY_BACKSPACE SL_KEY_C1 SL_KEY_C3 SL_KEY_DELETE SL_KEY_DOWN SL_KEY_END SL_KEY_ENTER SL_KEY_ERR SL_KEY_F0 SL_KEY_HOME SL_KEY_IC SL_KEY_LEFT SL_KEY_NPAGE SL_KEY_PPAGE SL_KEY_REDO SL_KEY_RIGHT SL_KEY_UNDO SL_KEY_UP SLSMG_DARROW_CHAR SLSMG_BLOCK_CHAR SLSMG_BOARD_CHAR SLSMG_BULLET_CHAR SLSMG_DEGREE_CHAR SLSMG_DIAMOND_CHAR SLSMG_LARROW_CHAR SLSMG_PLMINUS_CHAR SLSMG_RARROW_CHAR SLSMG_UARROW_CHAR ); %EXPORT_TAGS = ( 'CONSTANTS' => [ grep /^SL(?:ANG|SMG|TT|_KEY)_/, @EXPORT_OK ], 'screen' => [ grep /^SLsmg_/, @EXPORT_OK ], 'common' => [ grep /^SL(?:ang|sig|tty|rline)_/, @EXPORT_OK ], 'term' => [ grep /^SLtt_/, @EXPORT_OK ], 'signal' => [ grep /^SLsig_/, @EXPORT_OK ], 'keys' => [ grep /^SLkp_/, @EXPORT_OK ], 'scroll' => [ grep /^SLscroll_/, @EXPORT_OK ], 'all' => [ @EXPORT_OK], ); BOOT_XS: { # If I inherit DynaLoader then I inherit AutoLoader and I DON'T WANT TO. require DynaLoader; # DynaLoader calls dl_load_flags as a static method. *dl_load_flags = DynaLoader->can('dl_load_flags'); do {__PACKAGE__->can('bootstrap') || \&DynaLoader::bootstrap}->(__PACKAGE__,$VERSION); } 1; __END__ =head1 NAME Term::Slang - Interface to the S-Lang terminal library. =head1 SYNOPSIS use Term::Slang qw(:all); SLtt_get_terminfo(); SLang_init_tty(-1,0,1); SLsig_block_signals(); SLsmg_init_smg; SLsig_unblock_signals(); SLkp_init(); =head1 DESCRIPTION Please see the S-Lang API documentation. =head1 AUTHOR Daniel Sully Edaniel-cpan-slang@electricrain.comE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =head1 SEE ALSO slang(1), perl(1) =cut Term-Slang-0.07/demo/0040755000076500007650000000000007076425434013640 5ustar danieldanielTerm-Slang-0.07/demo/keypad0100755000076500007650000000121206763265276015044 0ustar danieldaniel#!/usr/bin/perl -w # This is a port of the keypad.c demo. # $Id: keypad,v 1.2 1999/09/01 18:04:46 daniel Exp $ use strict; use ExtUtils::testlib; use Term::Slang qw(:common :keys); SLang_init_tty(-1,0,1); SLsig_block_signals(); SLsig_unblock_signals(); SLkp_init(); my $timeout = 2; print "This program illustrates the slkeypad facility.\n"; print "Press any key ('q' quits).\n"; while(SLang_input_pending(1000)) { my $ch = SLang_getkey(); if ($ch == 033) { last if SLang_input_pending($timeout) == 0; } SLang_ungetkey($ch); $ch = SLkp_getkey; last if $ch == 113; printf "Keysym: %d\r\n", $ch; } SLang_reset_tty(); __END__ Term-Slang-0.07/demo/cursor0100755000076500007650000000206506763265232015103 0ustar danieldaniel#!/usr/bin/perl -w # $Id: cursor,v 1.2 1999/09/01 18:04:10 daniel Exp $ use strict; use ExtUtils::testlib; use Term::Slang qw(:all); SLtt_get_terminfo(); SLang_init_tty(-1,0,1); SLsig_block_signals(); SLsmg_init_smg; SLsig_unblock_signals(); SLkp_init(); my ($s_rows,$s_cols) = SLtt_get_screen_size(); my $r = 10; SLsmg_normal_video(); SLsmg_gotorc($r,0); print "Version: $Term::Slang::VERSION\n"; print "Use the up and down arrows to continue\n"; print "Press any key ('q' quits).\n"; while(my $key = SLkp_getkey()) { last if $key == 113; # Up 258 if ($key == 258) { SLsmg_gotorc($r,0); SLsmg_erase_eol(); $r++; SLsmg_gotorc($r,0); SLsmg_write_string("-> $r - $key"); SLsmg_refresh(); if ($r >= $s_rows) { SLtt_beep(); $r = $s_rows - 1; next; } } # Down 257 if ($key == 257) { SLsmg_gotorc($r,0); SLsmg_erase_eol(); $r--; SLsmg_gotorc($r,0); SLsmg_write_string("-> $r - $key"); SLsmg_refresh(); if ($r <= 0) { SLtt_beep(); $r = 1; next; } } } SLsmg_refresh(); SLang_reset_tty(); SLsmg_reset_smg(); __END__ Term-Slang-0.07/demo/draw-box0100755000076500007650000000272107076016343015303 0ustar danieldaniel#!/usr/bin/perl -w # $Id: draw-box,v 1.4 2000/03/29 17:48:20 daniel Exp $ use strict; use ExtUtils::testlib; use Term::Slang qw(:all); SLtt_get_terminfo(); SLang_init_tty(-1,0,1); SLsig_block_signals(); SLsmg_init_smg(); SLsmg_cls(); SLsig_unblock_signals(); SLkp_init(); my $q = 'oink.'; my $dc = (length $q) + 2; my $dr = 7; $dc = 36 if $dc < 32; my ($s_rows,$s_cols) = SLtt_get_screen_size(); my $r = ($s_rows - $dr)/2; my $c = ($s_cols - $dc)/2; my $box_color = 2; my $button_color = 3; define_color($button_color,'white','green'); define_color($box_color,'yellow','blue'); SLsmg_set_color($box_color); SLsmg_draw_box($r,$c,$dr,$dc); SLsmg_set_color(0); $r += 2; draw_centered_string($q,$r,$c,$dc); $r += 2; display_button('Yes',$r,$c + 4); display_button('No', $r,$c + 14); display_button('Cancel',$r,$c + 24); SLsmg_refresh(); while(my $k = SLkp_getkey()) { if ($k eq SL_KEY_LEFT) { SLsmg_write_string("foo"); last; } } SLang_reset_tty(); SLsmg_reset_smg(); ########################## sub draw_centered_string { my ($s,$r,$c,$dc) = @_; SLsig_block_signals(); SLsmg_gotorc($r,$c + ($dc - (length $s))/2); SLsmg_write_string($s); SLsig_unblock_signals(); } sub display_button { my ($name,$r,$c) = @_; SLsig_block_signals(); SLsmg_gotorc($r,$c); SLsmg_set_color($button_color); SLsmg_write_string(" $name "); SLsmg_set_color(0); SLsig_unblock_signals(); } sub define_color { my ($obj,$fg,$bg) = @_; SLtt_set_color($obj,'',$fg,$bg); } __END__ Term-Slang-0.07/demo/smgtest0100755000076500007650000001722007076016343015246 0ustar danieldaniel#!/usr/bin/perl -w # $Id: smgtest,v 1.4 2000/03/29 17:48:20 daniel Exp $ use strict; use ExtUtils::testlib; use Term::Slang qw(:all); SLtt_get_terminfo(); SLang_init_tty(-1,0,1); SLsig_block_signals(); SLsmg_init_smg; SLsig_unblock_signals(); SLkp_init(); my ($s_rows,$s_cols) = SLtt_get_screen_size(); my @colors = qw( black red green brown blue magenta cyan lightgray gray brightred brightgreen yello brightblue brightmagenta brightcyan white ); my $num_colors = scalar @colors; init_colors(); SLtt_set_mouse_mode(1,0); menu_loop(); quit(); ############### sub quit { SLang_reset_tty(); SLsmg_reset_smg(); exit; } sub print_menu { SLsig_block_signals(); SLsmg_cls(); my $row = 2; my $i = 1; my @names = ( 'Color Test', 'Alt charset test', 'Key Escape Sequence Report', 'Line Drawing Test', 'Test Mouse', 'Box Test', 'Test Low Level Functions', 'Quit', ); for my $name (@names) { SLsmg_gotorc($row, 3); SLsmg_write_string("$i $name"); $row++; $i++; } $row = 0; SLsmg_gotorc($row, 1); SLsmg_write_string('Choose number:'); SLsmg_refresh(); SLsig_unblock_signals(); } sub menu_loop { print_menu(); my @names = ('', \&color_test,\&alt_char_test,\&esc_seq_test,\&line_test, \&mouse_test,\&box_test,\&low_level_test,\&quit, ); while (1) { my $ch = chr SLkp_getkey(); if ($names[$ch]) { &{$names[$ch]}; } elsif ($ch eq '\r') { next; } else { SLtt_beep(); } print_menu(); } } sub write_centered_string { my ($s,$row) = @_; my $col; return if $s =~ /^\s*$/; my $len = length $s; # Want 2 * col + len == SLtt_Screen_Rows $col = $len >= $s_cols ? 0 : ($s_cols - $len) / 2; SLsmg_gotorc($row,$col); SLsmg_write_string($s); } sub pre_test { my $title = shift; SLsig_block_signals; SLsmg_cls; write_centered_string($title,0); } sub post_test { write_centered_string('Press any key to return.',$s_rows - 1); SLsmg_refresh; SLsig_unblock_signals; SLkp_getkey; } sub init_colors { for(my $i = 0; $i < $num_colors; $i++) { SLtt_set_color($i+1,'','black',$colors[$i]); } } # The tests. sub box_test { my $msg = 'This is a box with changing background'; my $color; pre_test('Box Test'); my $dr = 8; my $dc = 4 + length $msg; my $r = $s_rows / 2 - $dr/2; my $c = $s_cols / 2 - $dc/2; SLsmg_set_color(1); SLsmg_set_char_set(1); SLsmg_fill_region($r + 1, $c + 1, $dr - 2, $dc - 2, 'a'); SLsmg_set_char_set(0); SLsmg_set_color(0); SLsmg_gotorc($r + $dr/2, $c + 2); SLsmg_write_string($msg); SLsmg_draw_box($r, $c, $dr, $dc); SLsmg_refresh(); $color = 2; while (0 == SLang_input_pending(10)) { SLsmg_set_color_in_region($color,$r,$c,$dr,$dc); SLsmg_refresh(); $color++; $color = $color % $num_colors; } post_test(); } sub color_test { pre_test('Color Test'); my $row = 1; my $color = 0; while ($row < $s_rows - 1) { $color = $color % $num_colors; SLsmg_gotorc($row, 0); SLsmg_set_color(0); SLsmg_write_string($colors[$color]); $color++; SLsmg_set_color($color); SLsmg_erase_eol; $row++; } SLsmg_set_color(0); post_test(); } sub alt_char_test { pre_test('Alternate Charset Test'); my $row = $s_rows / 2 - 2; my $col = 0; for (my $ch = 32; $ch < 128; $ch++) { SLsmg_gotorc($row, $col); SLsmg_write_char(chr $ch); SLsmg_gotorc($row + 1, $col); SLsmg_set_char_set(1); SLsmg_write_char(chr $ch); SLsmg_set_char_set(0); $col++; if ($col > 40) { $col = 0; $row += 4; } } post_test(); } sub line_test { pre_test('Line Test'); my $row = 4; my $col = 2; SLsmg_gotorc($row, $col); SLsmg_draw_hline(10); SLsmg_write_string('Result of SLsmg_draw_hline(10)'); SLsmg_draw_vline(5); SLsmg_write_string('Result of SLsmg_draw_vline(5)'); post_test(); } sub esc_seq_test { pre_test('Escape Sequence Report'); my $row = $s_rows / 2; SLsmg_gotorc($row, 0); SLsmg_write_string('Press key: '); SLsmg_refresh(); SLsmg_gotorc($row, 0); SLsmg_write_string('Key returned '); my $ch = SLang_getkey(); my $buf = '"'; if ($ch >= 127) { $buf .= sprintf("\\d%d", $ch); } elsif ($ch eq '"' or $ch eq '\\') { $buf .= '\\'.chr $ch; } else { $buf .= chr $ch; } while (SLang_input_pending(3) > 0) { } $buf .= '"'; SLsmg_write_string($buf); post_test(); } sub mouse_test { pre_test('Mouse Test'); my $row = $s_rows / 2; SLsmg_gotorc($row, 0); SLsmg_write_string('Click Mouse: '); SLsmg_refresh(); my $ch = SLang_getkey(); if ($ch != 27) { SLsmg_gotorc($row, 0); SLsmg_write_string('That did not appear to be a mouse escape sequence'); SLsmg_gotorc($row+1,0); SLsmg_write_string("You pressed: $ch"); post_test(); return; } my $b = SLang_getkey(); my $x = SLang_getkey(); my $y = SLang_getkey(); SLsmg_gotorc($row, 0); SLsmg_write_string("Button: $b "); SLsmg_gotorc($row + 1, 0); SLsmg_write_string("Column: $x"); SLsmg_gotorc($row + 2, 0); SLsmg_write_string(" Row: $y"); SLang_getkey(); SLang_getkey(); post_test(); } sub low_level_test { # XXX not implemented yet #if (SLtt_Term_Cannot_Scroll) { # pre_test('Sorry! Your terminal lacks scrolling capability.'); # post_test(); # return; #} SLsmg_suspend_smg(); SLtt_init_video(); my $mid = $s_rows / 2; my $bot = $s_rows - 1; SLtt_cls(); SLtt_goto_rc(0, 0); SLtt_write_string("The following set of tests are designed to test the display system."); SLtt_goto_rc(1, 0); SLtt_write_string("There should be a line of text in the middle and one at the bottom."); SLtt_goto_rc($mid, 0); SLtt_write_string("This line is in the middle."); SLtt_goto_rc($bot, 0); SLtt_write_string("This line is at the bottom."); SLtt_goto_rc(2, 0); SLtt_write_string("Press return now."); SLtt_flush_output(); SLang_flush_input(); SLang_getkey(); SLtt_goto_rc(2, 0); SLtt_write_string("The middle row should slowly move down next the bottom and then back up."); SLtt_goto_rc($mid - 1, 0); SLtt_write_string("This line should not move."); SLtt_goto_rc($mid + 1, 0); SLtt_write_string("This line should vanish at the bottom"); SLtt_goto_rc($mid + 1, $s_cols - 5); SLtt_write_string("End->"); SLtt_flush_output(); SLtt_set_scroll_region($mid, $bot - 1); my $r = ($bot - $mid) - 1; while ($r > 0) { SLang_input_pending(2); # 3/10 sec delay SLtt_goto_rc(0,0); # relative to scroll region SLtt_reverse_index(1); SLtt_flush_output(); $r--; } $r = ($bot - $mid) - 1; while ($r > 0) { SLang_input_pending(2); SLtt_goto_rc(0,0); SLtt_delete_nlines(1); SLtt_flush_output(); $r--; } SLtt_reset_scroll_region(); SLtt_goto_rc($mid - 1, 0); SLtt_write_string("Now the bottom will come up and clear the lines below"); SLtt_set_scroll_region($mid, $bot); $r = ($bot - $mid) + 1; while ($r > 0) { SLang_input_pending(2); SLtt_goto_rc(0,0); SLtt_delete_nlines(1); SLtt_flush_output(); $r--; } SLtt_reset_scroll_region(); SLtt_goto_rc(3,0); SLtt_write_string("This line will go down and vanish"); SLtt_set_scroll_region(3, $mid - 2); $r = (($mid - 2) - 3) + 1; while ($r > 0) { SLang_input_pending(3); SLtt_goto_rc(0,0); SLtt_reverse_index(1); SLtt_flush_output(); $r--; } SLtt_reset_scroll_region(); SLtt_set_scroll_region(1,1); SLtt_goto_rc (0,0); SLtt_delete_nlines(1); SLtt_reset_scroll_region(); SLtt_set_scroll_region(2,2); SLtt_goto_rc(0,0); SLtt_reverse_index(1); SLtt_reset_scroll_region(); SLtt_goto_rc(1, 10); SLtt_write_string("Press Any Key To Continue."); SLtt_flush_output(); $r = 15; #if (0 == SLtt_Term_Cannot_Insert()) { while ($r) { $r--; SLtt_goto_rc(1, 0); SLtt_begin_insert(); SLtt_putchar(' '); SLtt_end_insert(); SLtt_flush_output(); SLang_input_pending(2); } #} SLang_flush_input(); SLang_getkey(); SLtt_reset_video(); SLsmg_resume_smg(); } __END__ Term-Slang-0.07/TODO0100644000076500007650000000007407065336136013400 0ustar danieldaniel Scroll_Window_Type struct interface. Documentation Tests Term-Slang-0.07/Slang/0040755000076500007650000000000007076425434013760 5ustar danieldanielTerm-Slang-0.07/Slang/Window.pm0100644000076500007650000000274207030262401015546 0ustar danieldanielpackage Term::Slang::Window; # $Id: Window.pm,v 1.1 1999/12/22 23:55:45 daniel Exp $ use strict; use Data::Dumper; #use DynaLoader; use Tie::Hash; use vars qw($VERSION @ISA @EXPORT_OK %EXPORT_TAGS $AUTOLOAD); @ISA = qw(Tie::Hash); $VERSION = '0.03'; # bootstrap Term::Slang $VERSION; sub DESTROY { die unless @_ == 1; my $self = shift; Term::Slang::SLscroll_destroy($self); } sub TIEHASH { die "Usage: tie %arr, __PACKAGE__\n" unless @_ == 1; my $proto = shift; my $window = Term::Slang::SLscroll_create(); bless my $self = { 'window' => $window }, (ref $proto || $proto); return $self; } sub STORE { my ($self, $key, $val) = @_; die unless @_ == 3; Term::Slang::SLscroll_set($self->{'window'}, $key, $val); } sub FETCH { my ($self, $key) = @_; die unless @_ == 2; Term::Slang::SLscroll_get($self->{'window'}, $key); } sub DELETE { my ($self, $key) = @_; die unless @_ == 2; SLscroll_set($self, $key, undef); } sub EXISTS { my ($self, $key) = @_; die unless @_ == 2; my $val = SLscroll_get($self, $key); return 1 if defined $val; return 0; } sub FIRSTKEY { 1 } sub NEXTKEY { 1 } 1; __END__ =head1 NAME Term::Slang - Interface to the S-Lang terminal library. =head1 SYNOPSIS =head1 DESCRIPTION Please see the S-Lang API documentation. =head1 AUTHOR Daniel Edaniel-cpan-slang@electricrain.comE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =head1 SEE ALSO slang(1), perl(1) =cut Term-Slang-0.07/Slang/Scroll.pm0100644000076500007650000000315007065514132015540 0ustar danieldanielpackage Term::Slang::Scroll; # $Id: Scroll.pm,v 1.2 2000/03/20 05:40:01 daniel Exp $ use strict; use Data::Dumper; #use DynaLoader; use Tie::Hash; use vars qw($VERSION @ISA @EXPORT_OK %EXPORT_TAGS $AUTOLOAD); @ISA = qw(Tie::Hash); $VERSION = '0.03'; # bootstrap Term::Slang $VERSION; sub DESTROY { die unless @_ == 1; my $self = shift; Term::Slang::SLline_destroy($self->{'line'}); } sub TIEHASH { die "Usage: tie %arr, __PACKAGE__\n" unless @_ == 1; my $proto = shift; my $line = Term::Slang::SLline_create(ref $proto || $proto); bless my $self = { 'line' => $line }, (ref $proto || $proto); return $self; } sub STORE { my ($self, $key, $val) = @_; die unless @_ == 3; #print '-' x 50, "\n"; #print "VALUE DUMP: ", Dumper($val); #print "VALUE REF: ", ref($val), "\n"; #print '-' x 50, "\n"; Term::Slang::SLline_set($self->{'line'}, $key, $val); } sub FETCH { my ($self, $key) = @_; die unless @_ == 2; Term::Slang::SLline_get($self->{'line'}, $key); } sub DELETE { my ($self, $key) = @_; die unless @_ == 2; SLline_set($self, $key, undef); } sub EXISTS { my ($self, $key) = @_; die unless @_ == 2; my $val = SLline_get($self, $key); return 1 if defined $val; return 0; } sub FIRSTKEY { 1 } sub NEXTKEY { 1 } 1; __END__ =head1 NAME Term::Slang - Interface to the S-Lang terminal library. =head1 SYNOPSIS =head1 DESCRIPTION Please see the S-Lang API documentation. =head1 AUTHOR Daniel Edaniel-cpan-slang@electricrain.comE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =head1 SEE ALSO slang(1), perl(1) =cut Term-Slang-0.07/MANIFEST0100644000076500007650000000023607023113326014025 0ustar danieldanielChanges MANIFEST Makefile.PL README Slang.pm Slang.xs Slang/Scroll.pm Slang/Window.pm TODO test.pl typemap demo/cursor demo/draw-box demo/keypad demo/smgtest Term-Slang-0.07/Makefile.PL0100644000076500007650000000177007075003772014664 0ustar danieldaniel# $Id: Makefile.PL,v 1.2 1999/12/22 23:55:34 daniel Exp $ require 5.004_04; use ExtUtils::MakeMaker; use Config qw(%Config); sub MY::libscan { my ($self,$path) = @_; return '' if($path =~ m:/(RCS|CVS|SCCS)/: || $path =~ m:[~%]$: || $path =~ m:\.(orig|rej)$: ); return $path; } print "Checking for 'slang.h'\n"; my $include = ''; my @inc = split /\s+/,join(' ',$Config{'usrinc'},$Config{'incpth'},$Config{'locincpth'}); foreach my $path (@inc) { if (-f "$path/slang.h") { print "Checking in $path/...\n"; $include .= "-I$path "; last; } elsif (-f "$path/slang/slang.h") { print "Checking in $path/slang/...\n"; $include .= "-I$path/slang "; last; } } die "I can't find 'slang.h' - Exiting!\n" if $include =~ /^\s*$/; WriteMakefile( 'NAME' => 'Term::Slang', 'VERSION_FROM' => 'Slang.pm', 'LIBS' => ['-lslang'], 'DEFINE' => '', 'INC' => $include, 'PMLIBDIRS' => [ 'Slang' ], 'dist' => { COMPRESS => 'gzip -9f', SUFFIX => 'gz', DIST_DEFAULT => 'tardist', }, ); Term-Slang-0.07/Changes0100644000076500007650000000055207076425352014205 0ustar danieldanielRevision history for Perl extension Term::Slang. 0.07 - Redid constants to use newCONSTSUB hack around SLsmg_write_char brokenness. Removed autoloader dependency in Slang.pm 0.06 - Fixed cvs problem, constants. 0.05 - Added patches from Joey Hess. 0.03 - Changed API to mirror slang API, lost OO stuff. 0.01 - original version; created by h2xs 1.18 Term-Slang-0.07/test.pl0100644000076500007650000000063507076011537014224 0ustar danieldaniel######################### We start with some black magic to print on failure. # Change 1..1 below to 1..last_test_to_print . # (It may become useful if the test is moved to ./t subdirectory.) BEGIN { $| = 1; print "1..1\n"; } END {print "not ok 1\n" unless $loaded;} use Term::Slang qw(:all); $loaded = 1; print "ok 1\n"; ######################### End of black magic. # Ahhh! Nothing here yet! Try the demos. Term-Slang-0.07/README0100644000076500007650000000077107065336130013566 0ustar danieldanielPREREQUISITES ------------- Before you can build Term::Slang you need to have the following installed on your system: * Perl 5.004 or greater. * The Slang library, 1.4 or greater. Available at: ftp://space.mit.edu/pub/davis/slang/ To build, test and install this distribution type: perl Makefile.PL make test make install -- Daniel Sully This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. Term-Slang-0.07/Slang.xs0100644000076500007650000003713307076424423014335 0ustar danieldaniel /* $Id: Slang.xs,v 1.9 2000/04/16 20:56:51 daniel Exp $ */ #ifdef __cplusplus "C" { #endif #include "EXTERN.h" #include "perl.h" #include "XSUB.h" #ifdef __cplusplus } #endif #include typedef struct _Scroll_Line_Type { SV *sv_next; SV *sv_prev; char *data; } Scroll_Line_Type; /* typedef struct _Scroll_Line_Type { struct _Scroll_Line_Type *next; struct _Scroll_Line_Type *prev; char *data; } Scroll_Line_Type; */ MODULE = Term::Slang PACKAGE = Term::Slang ################################ # Screen management void SLsmg_fill_region(r,c,nr,nc,ch) int r; int c; unsigned int nr; unsigned int nc; unsigned char ch; void SLsmg_set_char_set(a) int a; int SLsmg_suspend_smg() int SLsmg_resume_smg() void SLsmg_erase_eol() void SLsmg_gotorc(row,col) int row; int col; void SLsmg_erase_eos() void SLsmg_reverse_video() void SLsmg_set_color(c) int c; void SLsmg_normal_video() void SLsmg_printf(fmt, ...) char *fmt; #void #SLsmg_vprintf(s,list) # char *s; # va_list list; void SLsmg_write_string(str) char *str; void SLsmg_write_nstring(str,len) char *str; unsigned int len; void SLsmg_write_char(ch) SV *ch; CODE: { if (SvIOK(ch)) { SLsmg_write_char(SvIV(ch)); } else { SLsmg_write_char(*SvPV(ch,PL_na)); } } void SLsmg_write_nchars(str,len) char *str; unsigned int len; void SLsmg_write_wrapped_string(str,p1,p2,p3,p4,p5) char *str int p1 int p2; int p5; unsigned int p3; unsigned int p4; void SLsmg_cls() void SLsmg_refresh() void SLsmg_touch_lines(p1,p2) int p1; unsigned int p2; int SLsmg_init_smg() CODE: RETVAL = SLsmg_init_smg(); RETVAL = RETVAL == 0 ? 1 : 0; OUTPUT: RETVAL int SLsmg_reinit_smg() void SLsmg_reset_smg() unsigned short SLsmg_char_at() void SLsmg_set_screen_start(r,c) int r; int c; CODE: SLsmg_set_screen_start(&r, &c); void SLsmg_draw_hline(p1) unsigned int p1; void SLsmg_draw_vline(p1) int p1; void SLsmg_draw_object(p1,p2,s) int p1; int p2; unsigned char s; void SLsmg_draw_box(p1,p2,p3,p4) int p1; int p2; unsigned int p3; unsigned int p4; int SLsmg_get_column() int SLsmg_get_row() void SLsmg_forward(p1) int p1; void SLsmg_write_color_chars(us1,ui1) unsigned short &us1; unsigned int ui1; unsigned int SLsmg_read_raw(us1,ui1) unsigned short &us1; unsigned int ui1; unsigned int SLsmg_write_raw(us1,ui1) unsigned short &us1; unsigned int ui1; void SLsmg_set_color_in_region(i1,i2,i3,ui1,ui2) int i1; int i2; int i3; unsigned int ui1; unsigned int ui2; void SLsmg_set_terminal_info(info) SLsmg_Term_Type *info; ################################ # Tty stuff. int SLang_init_tty(abort_char,flow_control,opost) int abort_char; int flow_control; int opost; void SLang_reset_tty() void SLtty_set_suspend_state(p1) int p1; int SLang_getkey_intr_hook() unsigned int SLang_getkey() int SLang_ungetkey_string(buf,buflen) unsigned char *buf; unsigned int buflen; int SLang_buffer_keystring(buf,buflen) unsigned char *buf; unsigned int buflen; int SLang_ungetkey(ch) unsigned char ch; void SLang_flush_input() int SLang_input_pending(tsecs) int tsecs; int SLang_set_abort_signal(p1) void *p1; ################################ # Scrolling SLscroll_Window_Type * SLscroll_create() PREINIT: SLscroll_Window_Type *window; unsigned int nrows = 50; CODE: { window = safemalloc(sizeof(SLscroll_Window_Type)); window->nrows = nrows; RETVAL = window; } OUTPUT: RETVAL # unsigned int flags; # SLscroll_Type *top_window_line; /* list element at top of window */ # SLscroll_Type *bot_window_line; /* list element at bottom of window */ # SLscroll_Type *current_line; /* current list element */ # SLscroll_Type *lines; /* first list element */ # unsigned int nrows; /* number of rows in window */ # unsigned int hidden_mask; /* applied to flags in SLscroll_Type */ # unsigned int line_num; /* current line number (visible) */ # unsigned int num_lines; /* total number of lines (visible) */ # unsigned int window_row; /* row of current_line in window */ # unsigned int border; /* number of rows that form scroll border */ # int cannot_scroll; /* should window scroll or recenter */ # SLscroll_Window_Type; void SLscroll_get(window, key) SLscroll_Window_Type *window; char *key; PREINIT: SV *sv; PPCODE: { if (strEQ(key, "flags")) { sv = newSViv(window->flags); } else if (strEQ(key, "top_window_line")) { sv = newSVpv((char*)window->top_window_line, 0); } else if (strEQ(key, "bot_window_line")) { sv = newSVpv((char*)window->bot_window_line, 0); } else if (strEQ(key, "current_line")) { sv = newSVpv((char*)window->current_line, 0); } else if (strEQ(key, "lines")) { sv = newSVpv((char*)window->lines, 0); } else if (strEQ(key, "nrows")) { sv = newSViv(window->nrows); } else if (strEQ(key, "hidden_mask")) { sv = newSViv(window->hidden_mask); } else if (strEQ(key, "line_num")) { sv = newSViv(window->line_num); } else if (strEQ(key, "num_lines")) { sv = newSViv(window->num_lines); } else if (strEQ(key, "window_row")) { sv = newSViv(window->window_row); } else if (strEQ(key, "border")) { sv = newSViv(window->border); } else if (strEQ(key, "cannot_scroll")) { sv = newSViv(window->cannot_scroll); } XPUSHs(sv); } void SLscroll_destroy(window) SLscroll_Window_Type *window; CODE: { safefree(window); } void SLscroll_set(window, key, val) SLscroll_Window_Type *window; char *key; SV *val; CODE: { if (strEQ(key, "flags")) { window->flags = SvIV(val); } else if (strEQ(key, "top_window_line")) { window->top_window_line = (SLscroll_Type*)SvPV(val, PL_na); } else if (strEQ(key, "bot_window_line")) { window->bot_window_line = (SLscroll_Type*)SvPV(val, PL_na); } else if (strEQ(key, "current_line")) { window->current_line = (SLscroll_Type*)SvPV(val, PL_na); } else if (strEQ(key, "lines")) { window->lines = (SLscroll_Type*)SvPV(val, PL_na); } else if (strEQ(key, "nrows")) { window->nrows = SvUV(val); } else if (strEQ(key, "hidden_mask")) { window->hidden_mask = SvUV(val); } else if (strEQ(key, "line_num")) { window->line_num = SvUV(val); } else if (strEQ(key, "num_lines")) { window->num_lines = SvUV(val); } else if (strEQ(key, "window_row")) { window->window_row = SvUV(val); } else if (strEQ(key, "border")) { window->border = SvUV(val); } else if (strEQ(key, "cannot_scroll")) { window->cannot_scroll = SvIV(val); } } ############################################# Scroll_Line_Type * SLline_create(CLASS) char *CLASS; CODE: { RETVAL = (Scroll_Line_Type*)safemalloc(sizeof(Scroll_Line_Type)); if (RETVAL == NULL) { warn("Unable to malloc Scroll_Line_Type"); XSRETURN_UNDEF; } } OUTPUT: RETVAL void SLline_destroy(self) Scroll_Line_Type *self; CODE: { if (self->sv_next != NULL) { SvREFCNT_dec( self->sv_next ); } if (self->sv_prev != NULL) { SvREFCNT_dec( self->sv_prev ); } safefree((char*)self); } void SLline_get(lines, key) Scroll_Line_Type *lines; char *key; PREINIT: SV *sv; PPCODE: { if (strEQ(key, "next")) { sv = (Scroll_Line_Type*)SvPV( lines->sv_next, PL_na ); /* c = (PAIR*)SvIV( c->sv_next ); */ } else if (strEQ(key, "prev")) { /* sv = newSVpv((char*)lines->sv_prev, 0); */ sv = (Scroll_Line_Type*)SvIV( lines->sv_prev ); } else if (strEQ(key, "data")) { sv = newSVpv((char*)lines->data, 0); } XPUSHs(sv); } void SLline_set(self, key, val) Scroll_Line_Type *self; char *key; SV *val; CODE: { Scroll_Line_Type *foo; foo = (Scroll_Line_Type*)safemalloc(sizeof(Scroll_Line_Type)); printf("in SLline_set\n"); /* foo = (Scroll_Line_Type*)SvRV(val); printf("in SLline_set\n"); printf("VAL1: %s\n", (char*)foo->data); */ if (strEQ(key, "next")) { self->sv_next = SvRV(val); SvREFCNT_inc( self->sv_next ); if (SvIOK(self->sv_next)) { foo = (Scroll_Line_Type*)self->sv_next; printf("SLline_set->next->data: %s\n", (char*)foo->data); } } else if (strEQ(key, "prev")) { self->sv_prev = SvRV(val); SvREFCNT_inc( self->sv_prev ); if (SvIOK(self->sv_prev)) { foo = (Scroll_Line_Type*)self->sv_prev; printf("SLline_set->prev->data: %s\n", (char*)foo->data); } } else if (strEQ(key, "data")) { self->data = (char*)SvPV(val, PL_na); printf("DATAVAL: %s\n", (char*)self->data); } } int SLscroll_find_top(scroll) SLscroll_Window_Type *scroll; int SLscroll_find_line_num(scroll) SLscroll_Window_Type *scroll; unsigned int SLscroll_next_n(scroll,ui1) SLscroll_Window_Type *scroll; unsigned int ui1; unsigned int SLscroll_prev_n(scroll,ui1) SLscroll_Window_Type *scroll; unsigned int ui1; int SLscroll_pageup(scroll) SLscroll_Window_Type *scroll; int SLscroll_pagedown(scroll) SLscroll_Window_Type *scroll; ################################ # Readline SLang_Read_Line_Type* SLang_rline_save_line(rline) SLang_RLine_Info_Type *rline; int SLang_init_readline(rline) SLang_RLine_Info_Type *rline; int SLang_read_line(rline) SLang_RLine_Info_Type *rline; int SLang_rline_insert(s) char *s; void SLrline_redraw(rline) SLang_RLine_Info_Type *rline; ################################ # Signals void SLsig_block_signals() void SLsig_unblock_signals() ################################ # Keys int SLkp_define_keysym(key,map) char *key; unsigned int map; int SLkp_init() int SLkp_getkey() ################################ # Low level int SLtt_flush_output() void SLtt_set_scroll_region(i1,i2) int i1; int i2; void SLtt_reset_scroll_region() void SLtt_reverse_video(i1) int i1; void SLtt_bold_video() void SLtt_begin_insert() void SLtt_end_insert() void SLtt_del_eol() void SLtt_goto_rc(i1,i2) int i1; int i2; void SLtt_delete_nlines(i1) int i1; void SLtt_delete_char() void SLtt_erase_line() void SLtt_normal_video() void SLtt_cls() void SLtt_beep() void SLtt_reverse_index(i1) int i1; void SLtt_smart_puts(us1,us2,i1,i2) unsigned short *us1; unsigned short *us2; int i1; int i2; void SLtt_write_string(s) char *s; void SLtt_putchar(s) char s; int SLtt_init_video() int SLtt_reset_video() void SLtt_get_terminfo() void SLtt_get_screen_size() PROTOTYPE: ; PPCODE: SLtt_get_screen_size(); EXTEND(sp,2); PUSHs(sv_2mortal(newSViv(SLtt_Screen_Rows))); PUSHs(sv_2mortal(newSViv(SLtt_Screen_Cols))); int SLtt_set_cursor_visibility(i1) int i1; int SLtt_set_mouse_mode(i1,i2) int i1; int i2; void SLtt_set_color(obj,name,fg,bg) int obj; char *name; char *fg; char *bg; void SLtt_set_mono(i1, s1, l1) int i1; char *s1; unsigned long l1; BOOT: { HV *stash = gv_stashpvn("Term::Slang", 11, TRUE); struct { char *n; I32 v; } Term__Slang__const[] = { #ifdef SLANG_GETKEY_ERROR {"SLANG_GETKEY_ERROR", SLANG_GETKEY_ERROR}, #endif #ifdef SLANG_VERSION {"SLANG_VERSION", SLANG_VERSION}, #endif #ifdef SLSMG_BLOCK_CHAR {"SLSMG_BLOCK_CHAR", SLSMG_BLOCK_CHAR}, #endif #ifdef SLSMG_BOARD_CHAR {"SLSMG_BOARD_CHAR", SLSMG_BOARD_CHAR}, #endif #ifdef SLSMG_BULLET_CHAR {"SLSMG_BULLET_CHAR", SLSMG_BULLET_CHAR}, #endif #ifdef SLSMG_CKBRD_CHAR {"SLSMG_CKBRD_CHAR", SLSMG_CKBRD_CHAR}, #endif #ifdef SLSMG_COLOR_BLACK {"SLSMG_COLOR_BLACK", SLSMG_COLOR_BLACK}, #endif #ifdef SLSMG_COLOR_BLUE {"SLSMG_COLOR_BLUE", SLSMG_COLOR_BLUE}, #endif #ifdef SLSMG_COLOR_BRIGHT_BLUE {"SLSMG_COLOR_BRIGHT_BLUE", SLSMG_COLOR_BRIGHT_BLUE}, #endif #ifdef SLSMG_COLOR_BRIGHT_BROWN {"SLSMG_COLOR_BRIGHT_BROWN", SLSMG_COLOR_BRIGHT_BROWN}, #endif #ifdef SLSMG_COLOR_BRIGHT_CYAN {"SLSMG_COLOR_BRIGHT_CYAN", SLSMG_COLOR_BRIGHT_CYAN}, #endif #ifdef SLSMG_COLOR_BRIGHT_GREEN {"SLSMG_COLOR_BRIGHT_GREEN", SLSMG_COLOR_BRIGHT_GREEN}, #endif #ifdef SLSMG_COLOR_BRIGHT_MAGENTA {"SLSMG_COLOR_BRIGHT_MAGENTA", SLSMG_COLOR_BRIGHT_MAGENTA}, #endif #ifdef SLSMG_COLOR_BRIGHT_RED {"SLSMG_COLOR_BRIGHT_RED", SLSMG_COLOR_BRIGHT_RED}, #endif #ifdef SLSMG_COLOR_BRIGHT_WHITE {"SLSMG_COLOR_BRIGHT_WHITE", SLSMG_COLOR_BRIGHT_WHITE}, #endif #ifdef SLSMG_COLOR_BROWN {"SLSMG_COLOR_BROWN", SLSMG_COLOR_BROWN}, #endif #ifdef SLSMG_COLOR_CYAN {"SLSMG_COLOR_CYAN", SLSMG_COLOR_CYAN}, #endif #ifdef SLSMG_COLOR_GRAY {"SLSMG_COLOR_GRAY", SLSMG_COLOR_GRAY}, #endif #ifdef SLSMG_COLOR_GREEN {"SLSMG_COLOR_GREEN", SLSMG_COLOR_GREEN}, #endif #ifdef SLSMG_COLOR_LGRAY {"SLSMG_COLOR_LGRAY", SLSMG_COLOR_LGRAY}, #endif #ifdef SLSMG_COLOR_MAGENTA {"SLSMG_COLOR_MAGENTA", SLSMG_COLOR_MAGENTA}, #endif #ifdef SLSMG_COLOR_RED {"SLSMG_COLOR_RED", SLSMG_COLOR_RED}, #endif #ifdef SLSMG_DARROW_CHAR {"SLSMG_DARROW_CHAR", SLSMG_DARROW_CHAR}, #endif #ifdef SLSMG_DEGREE_CHAR {"SLSMG_DEGREE_CHAR", SLSMG_DEGREE_CHAR}, #endif #ifdef SLSMG_DIAMOND_CHAR {"SLSMG_DIAMOND_CHAR", SLSMG_DIAMOND_CHAR}, #endif #ifdef SLSMG_DTEE_CHAR {"SLSMG_DTEE_CHAR", SLSMG_DTEE_CHAR}, #endif #ifdef SLSMG_HLINE_CHAR {"SLSMG_HLINE_CHAR", SLSMG_HLINE_CHAR}, #endif #ifdef SLSMG_LARROW_CHAR {"SLSMG_LARROW_CHAR", SLSMG_LARROW_CHAR}, #endif #ifdef SLSMG_LLCORN_CHAR {"SLSMG_LLCORN_CHAR", SLSMG_LLCORN_CHAR}, #endif #ifdef SLSMG_LRCORN_CHAR {"SLSMG_LRCORN_CHAR", SLSMG_LRCORN_CHAR}, #endif #ifdef SLSMG_LTEE_CHAR {"SLSMG_LTEE_CHAR", SLSMG_LTEE_CHAR}, #endif #ifdef SLSMG_NEWLINE_IGNORED {"SLSMG_NEWLINE_IGNORED", SLSMG_NEWLINE_IGNORED}, #endif #ifdef SLSMG_NEWLINE_MOVES {"SLSMG_NEWLINE_MOVES", SLSMG_NEWLINE_MOVES}, #endif #ifdef SLSMG_NEWLINE_PRINTABLE {"SLSMG_NEWLINE_PRINTABLE", SLSMG_NEWLINE_PRINTABLE}, #endif #ifdef SLSMG_NEWLINE_SCROLLS {"SLSMG_NEWLINE_SCROLLS", SLSMG_NEWLINE_SCROLLS}, #endif #ifdef SLSMG_PLMINUS_CHAR {"SLSMG_PLMINUS_CHAR", SLSMG_PLMINUS_CHAR}, #endif #ifdef SLSMG_PLUS_CHAR {"SLSMG_PLUS_CHAR", SLSMG_PLUS_CHAR}, #endif #ifdef SLSMG_RARROW_CHAR {"SLSMG_RARROW_CHAR", SLSMG_RARROW_CHAR}, #endif #ifdef SLSMG_RTEE_CHAR {"SLSMG_RTEE_CHAR", SLSMG_RTEE_CHAR}, #endif #ifdef SLSMG_UARROW_CHAR {"SLSMG_UARROW_CHAR", SLSMG_UARROW_CHAR}, #endif #ifdef SLSMG_ULCORN_CHAR {"SLSMG_ULCORN_CHAR", SLSMG_ULCORN_CHAR}, #endif #ifdef SLSMG_URCORN_CHAR {"SLSMG_URCORN_CHAR", SLSMG_URCORN_CHAR}, #endif #ifdef SLSMG_UTEE_CHAR {"SLSMG_UTEE_CHAR", SLSMG_UTEE_CHAR}, #endif #ifdef SLSMG_VLINE_CHAR {"SLSMG_VLINE_CHAR", SLSMG_VLINE_CHAR}, #endif #ifdef SLTT_ALTC_MASK {"SLTT_ALTC_MASK", SLTT_ALTC_MASK}, #endif #ifdef SLTT_BLINK_MASK {"SLTT_BLINK_MASK", SLTT_BLINK_MASK}, #endif #ifdef SLTT_BOLD_MASK {"SLTT_BOLD_MASK", SLTT_BOLD_MASK}, #endif #ifdef SLTT_REV_MASK {"SLTT_REV_MASK", SLTT_REV_MASK}, #endif #ifdef SLTT_ULINE_MASK {"SLTT_ULINE_MASK", SLTT_ULINE_MASK}, #endif #ifdef SL_KEY_A1 {"SL_KEY_A1", SL_KEY_A1}, #endif #ifdef SL_KEY_A3 {"SL_KEY_A3", SL_KEY_A3}, #endif #ifdef SL_KEY_B2 {"SL_KEY_B2", SL_KEY_B2}, #endif #ifdef SL_KEY_BACKSPACE {"SL_KEY_BACKSPACE", SL_KEY_BACKSPACE}, #endif #ifdef SL_KEY_C1 {"SL_KEY_C1", SL_KEY_C1}, #endif #ifdef SL_KEY_C3 {"SL_KEY_C3", SL_KEY_C3}, #endif #ifdef SL_KEY_DELETE {"SL_KEY_DELETE", SL_KEY_DELETE}, #endif #ifdef SL_KEY_DOWN {"SL_KEY_DOWN", SL_KEY_DOWN}, #endif #ifdef SL_KEY_END {"SL_KEY_END", SL_KEY_END}, #endif #ifdef SL_KEY_ENTER {"SL_KEY_ENTER", SL_KEY_ENTER}, #endif #ifdef SL_KEY_ERR {"SL_KEY_ERR", SL_KEY_ERR}, #endif #ifdef SL_KEY_F0 {"SL_KEY_F0", SL_KEY_F0}, #endif #ifdef SL_KEY_HOME {"SL_KEY_HOME", SL_KEY_HOME}, #endif #ifdef SL_KEY_IC {"SL_KEY_IC", SL_KEY_IC}, #endif #ifdef SL_KEY_LEFT {"SL_KEY_LEFT", SL_KEY_LEFT}, #endif #ifdef SL_KEY_NPAGE {"SL_KEY_NPAGE", SL_KEY_NPAGE}, #endif #ifdef SL_KEY_PPAGE {"SL_KEY_PPAGE", SL_KEY_PPAGE}, #endif #ifdef SL_KEY_REDO {"SL_KEY_REDO", SL_KEY_REDO}, #endif #ifdef SL_KEY_RIGHT {"SL_KEY_RIGHT", SL_KEY_RIGHT}, #endif #ifdef SL_KEY_UNDO {"SL_KEY_UNDO", SL_KEY_UNDO}, #endif #ifdef SL_KEY_UP {"SL_KEY_UP", SL_KEY_UP}, #endif {Nullch,0}}; char *name; int i; for (i = 0; name = Term__Slang__const[i].n; i++) { newCONSTSUB(stash, name, newSViv(Term__Slang__const[i].v)); } }