Unix/Linux Go Back    


CentOS 7.0 - man page for slsh (centos section 1)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)


SLSH(1) 										  SLSH(1)

NAME
       slsh - Interpreter for S-Lang scripts

SYNOPSIS
       slsh  [ --help ] [ --version ] [ -g ] [ -n ] [ --init file ] [ --no-readline ] [ -e string
       ] [ -i ] [ -q, --quiet ] [ -t ] [ -v ] [ -|script-file args... ]

DESCRIPTION
       slsh is a simple program for interpreting S-Lang scripts.  It supports dynamic loading  of
       S-Lang modules and includes a readline interface for interactive use.

OPTIONS
       --help Show a summary of options

       --version
	      Show slsh version information

       -g     Compile with debugging code, tracebacks, etc

       -n     Don't load the personal initialization file

       --init file
	      Use this file instead of ~/.slshrc

       --no-readline
	      Do not use a readline interface for the interactive mode

       -e string
	      Execute ``string'' as S-Lang code.

       -i     Force  interactive mode.	Normally slsh will go into interactive mode if both stdin
	      and stdout are attached to a terminal.

       -q, --quiet
	      Startup quietly by not printing the version and copyright information.

       -t     Normally, slsh will call slsh_main if it is defined.   This  option  prevents  that
	      from happening making it useful for checking for syntax error.

       -v     Show  verbose  loading  messages.   This	is useful for seeing what files are being
	      loaded.

INITIALIZATION
       Upon startup, the program will try to load slsh.rc as follows. If either SLSH_CONF_DIR  or
       SLSH_LIB_DIR  environment  variables  exist, then slsh will look look in the corresponding
       directories for slsh.rc.  Otherwise it will look in:

       $(prefix)/etc/	(as specified in the Makefile)

       /usr/local/etc/

       /usr/local/etc/slsh/

       /etc/

       /etc/slsh/

       The slsh.rc file may load  other  files	from  slsh's  library  directory  in  the  manner
       described below.

       Once  slsh.rc  has been loaded, slsh will load $HOME/.slshrc if present.  Finally, it will
       load the script specified on the command line.  If the name of the script is  -,  then  it
       will  be  read  from stdin.  If the script name is not present, or a string to execute was
       not specified using the -e option, then slsh will go into interactive mode and read  input
       from the terminal.  If the script is present and defines a function called slsh_main, that
       function will be called.

LOADING FILES
       When a script loads a file via the built-in evalfile  function  or  the	require  function
       (autoloaded  by slsh.rc), the file is searched for along the SLSH_PATH as specified in the
       Makefile.  An alternate path may be specified by the SLSH_PATH environment variable.

       The search path may be queried and set during run time  via  the  get_slang_load_path  and
       set_slang_load_path functions, e.g.,

	  set_slang_load_path ("/home/bill/lib/slsh:/usr/share/slsh");

INTERACTIVE MODE
       When slsh is invoked without a script or is given the -i command line argument, it will go
       into into interactive mode.  In this mode, the user will be prompted for input.	The  pro-
       gram will leave this mode and exit if it sees an EOF (Ctrl-D) or the user exits by issuing
       the quit command.

       If an uncaught exception occurs during execution of a command, the error message  will  be
       shown and the user will be prompted for more input.

       Any objects left on the stack after a command will be printed and the stack cleared.  This
       makes interactive mode useful as a calculator, e.g.,

	    slsh> 3*10;
	    30
	    slsh> x = [1:20];
	    slsh> sum (sin(x)-cos(x));
	    0.458613
	    slsh> quit;
       Note that in this mode, variables are automatically declared.

       The interactive mode also supports command logging.  Logging is enabled by  the	start_log
       function.   The	stop_log  function will turn off logging.  The default file where logging
       information will be written is slsh.log.  An alternative may be specified as  an  optional
       argument to the start_log function:

	    slsh> start_log;
	    Logging input to slsh.log
       .
       .
	    slsh> stop_log;
	    slsh> start_log("foo.log");
	    Logging input to foo.log
       .
       .
	    slsh> stop_log;
	    slsh> start_log;
	    Logging input to foo.log

       Similarly,  the	save_input function may be used to save the previous input to a specified
       file:

	    slsh> save_input;
	    Input saved to slsh.log
	    slsh> save_input ("foo.log");
	    Input saved to foo.log

       As the above examples indicate, lines must end in a semicolon.  This is a basic feature of
       the language and permits commands to span multiple lines, e.g.,

	    slsh> x = [
		   1,2,3,
		   4,5,6];
	    slsh> sum(x);
       For  convenience  some users prefer that commands be automatically terminated with a semi-
       colon.  To have a semicolon silently appended to the end of an input line, put the follow-
       ing in $HOME/.slshrc file:

	   #ifdef __INTERACTIVE__
	   slsh_append_semicolon (1);
	   #endif

       The  interactive mode also supports shell escapes.  To pass a command to the shell, prefix
       it with !, e.g.,

	   slsh> !pwd
	   /grandpa/d1/src/slang2/slsh
	   slsh> !cd doc/tm
	   slsh> !pwd
	   /grandpa/d1/src/slang2/slsh/doc/tm

       Finally, the interactive mode supports a help and apropos function:

	   slsh> apropos list
	   apropos list ==>
	   List_Type
	   list_append
	   list_delete
       .
       .
	   slsh> help list_append
	   list_append

	    SYNOPSIS
	      Append an object to a list

	    USAGE
	      list_append (List_Type, object, Int_Type nth)
       .
       .
       For convenience, the help and apropos functions do not require the  syntactic  constraints
       of the other functions.

READLINE HISTORY MECHANISM
       By default, slsh is built to use the S-Lang readline interface, which includes a customiz-
       able command completion and a history mechanism.  When slsh  (or  any  S-Lang  application
       that makes use of this feature) starts in interactive mode, it will look for a file in the
       user's home directory called .slrlinerc and load it if present.	This file allows the user
       to  customize  the readline interface and enable the history to be saved between sessions.
       As an example, here is a version of the author's .slrlinerc file:

	    % Load some basic functions that implement the history mechanism
	    () = evalfile ("rline/slrline.rc");
	    % The name of the history file -- expands to .slsh_hist for slsh
	    RLine_History_File = "$HOME/.${name}_hist";

	    % Some addition keybindings.  Some of these functions are defined
	    % in rline/editfuns.sl, loaded by rline/slrline.rc
	    rline_unsetkey ("^K");
	    rline_setkey ("bol",   "^B");
	    rline_setkey ("eol",   "^E");
	    rline_setkey (&rline_kill_eol,  "^L");
	    rline_setkey (&rline_set_mark,  "^K^B");
	    rline_setkey (&rline_copy_region, "^Kk");
	    rline_setkey (&rline_kill_region, "^K^V");
	    rline_setkey (&rline_yank,	"^K^P");
	    rline_setkey ("redraw",   "^R");

	    #ifexists rline_up_hist_search
	    % Map the up/down arrow to the history search mechanism
	    rline_setkey (&rline_up_hist_search, "\e[A");
	    rline_setkey (&rline_down_hist_search, "\e[B");
	    #endif

	    #ifexists rline_edit_history
	    rline_setkey (&rline_edit_history, "^Kj");
	    #endif

	    % Add a new function
	    private define double_line ()
	    {
	       variable p = rline_get_point ();
	       variable line = rline_get_line ();
	       rline_eol ();
	       variable pend = rline_get_point ();
	       rline_ins (line);
	       rline_set_point (pend + p);
	    }
	   rline_setkey (&double_line,	"^K^L");

MISCELLANEOUS SCRIPTS
       Several useful example scripts are located in $prefix/share/slsh/scripts/,  where  $prefix
       represents the slsh installation prefix (/usr, /usr/local,...).	These scripts include:

       sldb   A script that runs the S-Lang debugger.

       jpegsize
	      Reports the size of a jpeg file.

       svnsh  A shell for browsing an SVN repository.

AUTHOR
       The principal author of slsh is John E. Davis <www.jedsoft.org>.  The interactive mode was
       provided by Mike Noble.	The S-Lang library upon which slsh is based is primarily the work
       of John E. Davis with help from many others.

       This  manual  page was originally written by Rafael Laboissiere for the Debian system (but
       may be used by others).

       Permission is granted to copy, distribute and/or modify this document under the	terms  of
       the GNU General Public License, Version 2 any later version published by the Free Software
       Foundation.

       On Debian systems, the complete text of the GNU General Public License  can  be	found  in
       /usr/share/common-licenses/GPL

					  28 March 2011 				  SLSH(1)
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums


All times are GMT -4. The time now is 04:57 AM.