Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
STATES(1)			     STATES			       STATES(1)

NAME
     states - awk alike text processing tool

SYNOPSIS
     states  [-hvV]  [-D var=val] [-f file] [-o outputfile] [-p path] [-s start-
     state] [-W level] [filename ...]

DESCRIPTION
     States is an awk-alike text processing tool with some state machine  exten-
     sions.   It is designed for program source code highlighting and to similar
     tasks where state information helps input processing.

     At a single point of time, States is in one state, each  quite  similar  to
     awk's  work  environment,	they  have regular expressions which are matched
     from the input and actions which are executed when a match is found.   From
     the action blocks, states can perform state transitions; it can move to an-
     other  state from which the processing is continued.  State transitions are
     recorded so states can return to the calling state once the  current  state
     has finished.

     The biggest difference between states and awk, besides state machine exten-
     sions,  is that states is not line-oriented.  It matches regular expression
     tokens from the input and once a match is processed, it continues	process-
     ing  from	the  current  position, not from the beginning of the next input
     line.

OPTIONS
     -D var=val, --define=var=val
	     Define variable var to have string value val.  Command line defini-
	     tions overwrite variable definitions found from the config file.

     -f file, --file=file
	     Read state definitions from file file.  As a default, states  tries
	     to  read state definitions from file states.st in the current work-
	     ing directory.

     -h, --help
	     Print short help message and exit.

     -o file, --output=file
	     Save output to file file instead of printing it to stdout.

     -p path, --path=path
	     Set the load path to path.  The load path defaults  to  the  direc-
	     tory, from which the state definitions file is loaded.

     -s state, --state=state
	     Start execution from state state.	This definition overwrites start
	     state resolved from the start block.

     -v, --verbose
	     Increase the program verbosity.

     -V, --version
	     Print states version and exit.

     -W level, --warning=level
	     Set the warning level to level.  Possible values for level are:

	     light   light warnings (default)

	     all     all warnings

STATES PROGRAM FILES
     States  program  files can contain on start block, startrules and namerules
     blocks to specify the initial state, state definitions and expressions.

     The start block is the main() of the states  program,  it	is  executed  on
     script  startup  for  each input file and it can perform any initialization
     the script needs.	 It  normally  also  calls  the  check_startrules()  and
     check_namerules() primitives which resolve the initial state from the input
     file  name or the data found from the beginning of the input file.  Here is
     a sample start block which initializes two variables and does the	standard
     start state resolving:

	    start
	    {
	      a = 1;
	      msg = "Hello, world!";
	      check_startrules ();
	      check_namerules ();
	    }

     Once  the	start block is processed, the input processing is continued from
     the initial state.

     The initial state is resolved by the information found from the  startrules
     and  namerules  blocks.   Both  blocks  contain regular expression - symbol
     pairs, when the regular expression is matched from the name of from the be-
     ginning of the input file, the initial state is named by the  corresponding
     symbol.   For example, the following start and name rules can distinguish C
     and Fortran files:

	    namerules
	    {
	      /\.(c|h)$/    c;
	      /\.[fF]$/     fortran;
	    }

	    startrules
	    {
	      /-\*- [cC] -\*-/	    c;
	      /-\*- fortran -\*-/   fortran;
	    }

     If these rules are used with the previously shown start block, states first
     check the beginning of input file.  If it has string -*- c -*-, the file is
     assumed to contain C code and the processing is started from  state  called
     c.  If the beginning of the input file has string -*- fortran -*-, the ini-
     tial state is fortran.  If none of the start rules matched, the name of the
     input  file is matched with the namerules.  If the name ends to suffix c or
     C, we go to state c.  If the suffix is f or F, the initial  state	is  for-
     tran.

     If both start and name rules failed to resolve the start state, states just
     copies its input to output unmodified.

     The start state can also be specified from the command line with option -s,
     --state.

     State definitions have the following syntax:

     state { expr {statements} ... }

     where  expr  is:  a  regular  expression,	special expression or symbol and
     statements is a list of statements.  When the expression  expr  is  matched
     from  the	input, the statement block is executed.  The statement block can
     call states' primitives, user-defined subroutines, call other states,  etc.
     Once the block is executed, the input processing is continued from the cur-
     rent  intput position (which might have been changed if the statement block
     called other states).

     Special expressions BEGIN and END can be used in the place  of  expr.   Ex-
     pression BEGIN matches the beginning of the state, its block is called when
     the  state  is  entered.	Expression END matches the end of the state, its
     block is executed when states leaves the state.

     If expr is a symbol, its value is looked up from the global environment and
     if it is a regular expression, it is matched to the input,  otherwise  that
     rule is ignored.

     The states program file can also have top-level expressions, they are eval-
     uated  after  the	program  file  is  parsed but before any input files are
     processed or the start block is evaluated.

PRIMITIVE FUNCTIONS
     call (symbol)
	     Move to state symbol and continue input file processing  from  that
	     state.   Function	returns  whatever the symbol state's terminating
	     return statement returned.

     calln (name)
	     Like call but the argument name is evaluated and its value must  be
	     string.   For  example,  this  function can be used to call a state
	     which name is stored to a variable.

     check_namerules ()
	     Try to resolve start state from namerules rules.  Function  returns
	     1 if start state was resolved or 0 otherwise.

     check_startrules ()
	     Try to resolve start state from startrules rules.	Function returns
	     1 if start state was resolved or 0 otherwise.

     concat (str, ...)
	     Concanate argument strings and return result as a new string.

     float (any)
	     Convert argument to a floating point number.

     getenv (str)
	     Get  value of environment variable str.  Returns an empty string if
	     variable var is undefined.

     int (any)
	     Convert argument to an integer number.

     length (item, ...)
	     Count the length of argument strings or lists.

     list (any, ...)
	     Create a new list which contains items any, ...

     panic (any, ...)
	     Report a non-recoverable error and exit with  status  1.	Function
	     never returns.

     print (any, ...)
	     Convert arguments to strings and print them to the output.

     range (source, start, end)
	     Return  a	sub-range of source starting from position start (inclu-
	     sively) to end (exclusively).  Argument source  can  be  string  or
	     list.

     regexp (string)
	     Convert string string to a new regular expression.

     regexp_syntax (char, syntax)
	     Modify  regular expression character syntaxes by assigning new syn-
	     tax syntax for character char.  Possible values for syntax are:

	     'w'     character is a word constituent

	     ' '     character isn't a word constituent

     regmatch (string, regexp)
	     Check if string string matches regular  expression  regexp.   Func-
	     tions returns a boolean success status and sets sub-expression reg-
	     isters $n.

     regsub (string, regexp, subst)
	     Search regular expression regexp from string string and replace the
	     matching  substring  with	string	subst.	 Returns  the  resulting
	     string.  The substitution string subst can contain $n references to
	     the n:th parenthesized sup-expression.

     regsuball (string, regexp, subst)
	     Like regsub but replace all matches of  regular  expression  regexp
	     from string string with string subst.

     require_state (symbol)
	     Check  that  the state symbol is defined.	If the required state is
	     undefined, the function tries  to	autoload  it.	If  the  loading
	     fails, the program will terminate with an error message.

     split (regexp, string)
	     Split string string to list considering matches of regular rexpres-
	     sion regexp as item separator.

     sprintf (fmt, ...)
	     Format arguments according to fmt and return result as a string.

     strcmp (str1, str2)
	     Perform  a  case-sensitive  comparision  for strings str1 and str2.
	     Function returns a value that is:

	     -1      string str1 is less than str2

	     0	     strings are equal

	     1	     string str1 is greater than str2

     string (any)
	     Convert argument to string.

     strncmp (str1, str2, num)
	     Perform a case-sensitive comparision for strings str1 and str2 com-
	     paring at maximum num characters.

     substring (str, start, end)
	     Return a substring of string str starting from position start  (in-
	     clusively) to end (exclusively).

BUILTIN VARIABLES
     $.      current input line number

     $n      the  n:th	parenthesized regular expression sub-expression from the
	     latest state regular expression or from the regmatch primitive

     $`      everything before the matched regular rexpression.  This is  usable
	     when  used  with the regmatch primitive; the contents of this vari-
	     able is undefined when used in action blocks to refer the data  be-
	     fore the block's regular expression.

     $B      an alias for $`

     argv    list of input file names

     filename
	     name of the current input file

     program
	     name of the program (usually states)

     version
	     program version string

FILES
     /usr/local/share/enscript/hl/*.st	     enscript's states definitions

SEE ALSO
     awk(1), enscript(1)

AUTHOR
     Markku Rossi <mtr@iki.fi> <http://www.iki.fi/~mtr/>

     GNU Enscript WWW home page: <http://www.iki.fi/~mtr/genscript/>

STATES				  Oct 23, 1998			       STATES(1)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=states&sektion=1&manpath=FreeBSD+Ports+15.1.quarterly>

home | help