intro_acl


	The Accelerator Command Language (ACL) is a simple scripting
	language for reading and setting ACNET devices.  This is intended
	to be very simple to use, and as a result there are many synonyms
	for commands as well as qualifiers.  Hopefully, if you enter
	commands that make sense to you, they will make sense to ACL.

	Devices are specified by their names with a couple of additions.
	You can specify the property with the second character in the name.
	A colon (:) or question mark (?) indicates the reading property,
	while an underscore (_) indicates the setting property, a pipe (|)
	character indicates basic status, an ampersand (&) character 
	indicates basic control, an at (@) character indicates the analog
	alarm, and a dollar sign ($) character indicates the digital alarm
	property.  An array index can be specified by appending the value
	to the end of the device name enclosed in square brackets "[n]".
	The array index value can be an integer constant, a variable,
	a symbol, or a device reading.  A range of array elements can be
	specified in a similar way with the notation "[start:end]".  If the
	ending array index is omitted, the maximum array element for that
	property is used.  You can also specify what portion of a property
	you want in bytes with the notation "{offset:length}".  You can
	further specify a device with the use of qualifiers.

	Examples of device qualifiers:

	/property=reading	-> select the reading property (default)
	/reading		-> select the reading property (default)
	/ftd=ftd_1hz		-> set the reading frequency to 1 Hz
	/ftd_1hz		-> set the reading frequency to 1 Hz
	/ftd_oneshot		-> request a one shot reading
	/ftd=evt02		-> request data on TCLK event 02
	/ftd=2hz		-> request data at a 2 Hz frequency
	/raw_ftd=60		-> request data at a 1 Hz frequency
	/event='p,1000,true'	-> request data at a 1 Hz frequency
	/period=2		-> request data every 2 seconds
	/period_msec=500	-> request data every 500 milliseconds
	/frequency=2		-> request data at a 2 Hz frequency
	/length=n		-> request n bytes of data
	/num_elements=n		-> request n array elements of data
	/num_values=n		-> request n array elements of data
	/atomic_size		-> request the atomic size for that property
	/all			-> request the maximum size for that property
	/maximum_size		-> request the maximum size for that property
	/offset=n		-> request data starting at a byte offset of n
	/index=n		-> request array element n (starts at 0)
	/array_index=n		-> request array element n (starts at 0)
	/raw			-> request raw (binary) data
	/scaled			-> request scaled data (default)
	/primary		-> request data in primary units
	/volts			-> request data in primary units
	/common			-> request scaled data (default)
	/string			-> request string data
	/name			-> request device name text
	/text			-> request device descriptive text
	/bit_status		-> request device bitwise status
	/state			-> request state text data (state devices only)
	/state_text		-> request state text data (state devices only)
	/date			-> request date string (raw data assumed to be
				   local time in seconds since Jan 1, 1970)
	/date_gmt		-> request date string (raw data assumed to be
				   GMT (UTC) time in seconds since Jan 1, 1970)
	/date_clinks		-> request date string (raw data assumed to be
				   local time in seconds since Jan 1, 1972)
	/acnet_error		-> request ACNET error string (raw data assumed
				   to be an ACNET error code)
	/node			-> request ACNET node string (raw data assumed
				   to be an ACNET node value)
	/ip_address		-> request IP address string
	/ip_name		-> request IP name string
	/source=dp		-> display data from the accelerator (default)
	/source=db		-> display data from the database
	/source=sr:1		-> display data from save/restore file 1
	/source=sda:1:"Inject Protons":1:ColliderShot	-> display data from SDA
							   file 1, case Inject Protons,
							   subcase (set) 1,
							   usage ColliderShot
	/source=dl:"01-JAN-2000 01:00"	-> display data from a Lumberjack at
					   January 1, 2000 at 0100
	/source=memory		-> display data from a memory pool

	Valid property strings:

	reading			-> reading property
	read			-> reading property
	prread			-> reading property
	setting			-> setting property
	set			-> setting property
	prset			-> setting property
	basic_status		-> basic status property
	status			-> basic status property
	sts			-> basic status property
	prbsts			-> basic status property
	basic_control		-> basic control property
	control			-> basic control property
	cntl			-> basic control property
	prbctl			-> basic control property
	analog_alarm		-> analog alarm property
	analog			-> analog alarm property
	aa			-> analog alarm property
	pranab			-> analog alarm property
	digital_alarm		-> digital alarm property
	digital			-> digital alarm property
	da			-> digital alarm property
	prdabl			-> digital alarm property

	The fields of analog and digital alarm blocks can be
	referenced through standard C structure notation with a
	dot ('.') separating the device name and the alarm block
	field name.

	Valid alarm block field names:

	.min[imum]			-> analog alarm minimum value
	.max[imum]			-> analog alarm maximum value
	.analog_nominal			-> analog alarm nominal value
	.tol[erance]			-> analog alarm tolerance value
	.nom[inal]			-> digital alarm nominal value
	.mask				-> digital alarm mask value
	.alarm_enable			-> alarm enable status
	.alarm_status			-> alarm good/bad status
	.tries_needed			-> alarm tries needed
	.tries_now			-> alarm tries now
	.alarm_ftd			-> alarm scan rate
	.abort				-> alarm abort capability
	.abort_inhibit			-> alarm abort inhibit status
	.limit_type			-> analog alarm limit type
	.flags				-> alarm flags field

	Some commands allow the caller to access multiple devices
	through the specification of a family device or through the
	use a list specifiers.  List specifiers can be either an
	ASCII text file name or a device database search specifier.

	Valid list specifiers:

	file={file name}		-> read devices from ASCII file
	db={table name}			-> read devices from a database table
					   containing device indices
	dbname={table name}		-> read devices from a database table
					   containing device names
	dbquery={SQL string}		-> list all devices from an
					   arbitrary database query
					   on tables containing device
					   indices
	dbqueryname={SQL string}	-> list all devices from an
					   arbitrary database query
					   on tables containing device
					   names
	devices='{device},{device}'	-> access an explicit list of devices
	node={node name}		-> access all devices from the
					   requested node
	node={wildcard node name}	-> access all devices from nodes whose
					   names match the requested string
	node={node}/crate={crate}	-> access all devices from the
					   requested crate
	node={node}/crate={crate}/slot={slot}	-> access all devices from the
						   requested slot
	node={node}/madc={madc number}	-> access all devices from the
					   requested MADC
	node={node}/property={property}	-> access all devices from a node which
					   have the requested property
	trunk={trunk number}		-> access all devices from the
					   requested ACNET trunk
	name={string}			-> access all devices containing a
					   particular string in their name
	full_name={string}		-> access all devices containing a
					   particular string in their full name
	name={string}/type={type}	-> access all devices containing a
					   particular string in their name
					   with a given device type
	family={string}			-> access all devices in a family device
	text={string}			-> access all devices containing a
					   particular string in their
					   descriptive text
	full_text={string}		-> access all devices containing a
					   particular string in their
					   full descriptive text
	device_type={type}		-> access all devices with the
					   requested device type
	device_type={type}/node={node}	-> access all devices with the
					   requested device type from a
					   given node
	device_type={type}/name={string} -> access all devices with the
					    requested device type which
					    a given string in their name
	device_class={class}		-> access all devices with the
					   requested device class
	device_class={class}/node={node}	-> access all devices with the
						   requested device class from
						   a given node
	save_list={list}		-> access all devices from the
					   requested save list
	user_save_list={list}		-> access all devices from the
					   requested user save list (usl)
	driver={driver}			-> access all devices with the
					   requested CAMAC driver type
	driver={driver}/node={node}	-> access all devices with the
					   requested CAMAC driver type
					   from a given node
	virtual_machine={device}	-> access all devices related to
					   a requested state device
	units={units_text}		-> access all devices having a given
					   units text
	alarm_list={list}		-> access all devices from the
					   requested alarm list
	user_alarm_list={system[\list]}	-> access all devices from the
					   requested user alarm list (ual)
	alarm_handler={handler}		-> access all devices having a
					   given alarm handler
	controlling_device={device}	-> access all devices controlled by
					   a given device
	expr[ession]={string}		-> access all devices containing
					   a given string in its
					   reading expression
	expr_device={device}		-> access all devices containing
					   a given device in its
					   reading expression
	ssdn={SSDN pattern}		-> access all devices having an SSDN
					   matching a pattern
	download_list={node}[\{crate}]	-> access all devices from the
					   requested node download list (dl)
	save_file={file_number}		-> list all devices saved in a
					   particular save file (sf)
	sda_case={usage}[:{case}]	-> list all devices configured for a
					   particular SDA case
	sda_set={file}:{case}:{set}	-> list all devices saved in a
					   particular SDA set
	logger_list={node}[:{list}]	-> list all devices on a given
					   data logger list
	siblings={device}		-> list all siblings descended from
					   a given device
	param_page={page}[:{subpage}]	-> list all devices on a given
					   parameter page
	wg_list={list_name}		-> list all devices from a
					   waveform generator list (I14/I15)
	console_class={class}		-> list all devices which are
					   settable by a console class
	user={user name}		-> list all devices modified by a
					   given user
	user_created={user name}	-> list all devices created
					   by a given user

	Generic device names can also be entered wherever a valid ACNET
	device name can be.  These names have the form "G:DEVnnn".  When
	the code is parsed, the generic device names are replaced with
	actual ACNET device names which are passed by the caller to
	the parsing routine.  The "nnn" is the index (starting at 0) of
	the name in the caller's device list that should be used to
	take the place of that generic device name.

	Lists of devices can also be established with the device_list
	command.  These lists can be accessed through pseudo device
	names of the form "Q:xxxxxx" where xxxxxx is the name given
	the list.

	There is also the concept of a "changeable" device.  A changeable
	device has a name of the form "G:CDVnn".  The actual device that
	is accessed by one of these pseudo devices can be set by the
	"change_device" command.

	Generic strings can also be entered for values in most commands.
	These replacement strings are similar to the replacement device
	names and have the form "stringnnn".  The "nnn" is the index
	(starting at 0) of the string in the caller' substitute string
	list that should be used to take the place of that generic string.
	This supports more generic scripts which have parameters that can
	be changed from one execution of the script to the next.  If a
	replacement string is to be interpreted as a string by the script,
	it should be enclosed in a string() function (ex. string(string0)).

	Values in the script can be stored in either variables which are
	destroyed when the script has completed or symbols which exist
	across script executions until they are deleted by a call to
	'acl_delete_symbol' or the calling program exits.  Symbol values
	can be read by the calling program through the routine
	'acl_read_symbol_c' and set through 'acl_set_symbol_c'.  Symbols
	must begin with a "$" character.  There are sixteen special symbols
	which are created and updated by ACL itself.  The symbol "$_value"
	typically contains the value of the last assignment.  The symbol
	"$_status" typically contains the status of the last ACL command
	executed.  The "$_string" symbol contains the last string produced
	by one of the string manipulation commands.  The symbol
	"$_error_string" contains the current verbose error string that will
	ultimately be returned to the ACL caller unless an error handler is
	invoked.  The symbol named "$_error_status" is only updated when an
	error handler is called and contains the error that caused the error
	handler to be invoked.  The symbol $_last_error_status is also
	updated in an error handler and stores the last error status seen.
	The symbol "$_error_device" contains the device index for the last
	device having a read, set, or database access error.  The symbol
	$_last_error_device contains the device index for the previous
	device having a read, set, or database access error.  The symbol
	$_error_count indicates how many times the current device has
	returned the present error status.  The symbol $_pending_count
	indicates how many consecutive times the last read device has
	returned a status of pending.  The symbol named $_return_value
	contains the value returned by the last return statement.  This
	symbol is only valid during the execution of the statement following
	the return.  The symbol named $_eof is a logical value indicating
	whether or not the most recent input request resulted in an end of
	file error.  The symbol named $_proc_status contains the status from
	the last call_proc statement.  The symbol named "$_num_device_args"
	contains the number of device arguments passed to the current script.
	The symbol named "$_num_string_args" contains the number of string
	arguments passed to the current script.  The symbol "$_num_devices"
	contains the number of devices processed by the last command.
	Finally, the symbol named "$_script_name" contains the name of the
	currently running script.  Both variables and symbols contain single
	values by default, but arrays of both types can be created through
	the use of the "declare" command.  Array indices use the common
	square bracket style used by C.  Array indices can be specified by
	integer constants, variables, symbols, or device values.

	Multiple commands can be entered on a single line by separating
	them with semicolons (;) or a a single command may span several
	lines by inserting a back slash (\) at the end of each line to
	be continued.  Otherwise, it is assumed that each source line
	defines one command.  In any case, a single command line cannot
	exceed 256 characters including white spaces.  Comments can be
	inserted anywhere in a line indicated by an exclamation point (!)
	or a pound (#) character.  All text in a line following a comment
	character is ignored.

	Several commands plus some data source specifications take
	dates as arguments.  The default format for dates is
	"dd-mmm-yyyy[ hh:mm]".  There are also several special
	formats.  The "past" format specifies a time a certain
	interval before the present time (e.g. "past_30min").  The
	"store" format indicates the date that a particular shot
	was started (e.g. "store_1000").  The "event" format indicates
	the last time a given event occurred (e.g. "event_4e").
	There are also various special date keywords.  These include
	"now" (present time), "today" (the start of the present day),
	"yesterday" (midnight yesterday), "tomorrow" (midnight
	tomorrow), "this_hour" (start of the present hour), "last_hour"
	(start of the last hour), "this_week" (the start of this week),
	"this_year" (the start of this year), plus several others.

	There are also a few reserved strings that have special
	interpretations:

	console_number		-> returns the caller's console number
	slot			-> returns the caller's console slot
	node_name		-> returns the caller's ACNET node name
	node_number		-> returns the caller's ACNET node (integer)
	my_node_number		-> returns the caller's ACNET node number
	my_trunk		-> returns the caller's ACNET trunk number
	console_class		-> returns the caller's console class mask
	is_mcr_class		-> returns 1 if the console is MCR class
	user_name		-> returns the current user name
	process_name		-> returns the current process name
	executable_name		-> returns the current executable image name
	full_executable_name	-> returns the current executable image name
				   including the path
	program_name		-> returns the current program name
	generic_program_name	-> returns the generic name of the
				   current program
	page			-> returns the current page name
	clib_date		-> returns the date of the current CLIB
	{console color strings} -> return the corresponding color value
	date (now)		-> returns the current date
	time			-> returns the current time of day
	current_time		-> returns the current time of day
	clinks[_now]		-> returns the current date in clinks
	ctime_now		-> returns the current date in C time
	gmt_now			-> returns the current date in GMT (UTC) seconds
	today			-> returns the time for today at midnight
	yesterday		-> returns the time for yesterday at midnight
	tomorrow		-> returns the time for tommorow at midnight
	this_minute		-> returns the time for the start of the
				   present minute
	last_minute		-> returns the time for the start of the
				   last minute
	next_minute		-> returns the time for the start of the
				   next minute
	this_hour		-> returns the time for the start of the
				   present hour
	last_hour		-> returns the time for the start of the
				   last hour
	next_hour		-> returns the time for the start of the
				   next hour
	this_shift		-> returns the time for the start of the
				   present shift
	last_shift		-> returns the time for the start of the
				   last shift
	next_shift		-> returns the time for the start of the
				   next shift
	this_week		-> returns the time for the start of the
				   present week
	last_week		-> returns the time for the start of the
				   last week
	next_week		-> returns the time for the start of the
				   next week
	this_month		-> returns the time for the start of the
				   present month
	last_month		-> returns the time for the start of the
				   last month
	next_month		-> returns the time for the start of the
				   next month
	this_year		-> returns the time for the start of the
				   present year
	last_year		-> returns the time for the start of the
				   last year
	next_year		-> returns the time for the start of the
				   next year
	script_time		-> returns the total script execution time
	delta_script_time	-> returns the script execution time since
				   the last reference to 'delta_script_time'
	{ACNET error strings}	-> return the corresponding ACNET error value
	version			-> returns the current ACL version
	last_big_save		-> last big save file number
	last_shot_save		-> last shot save file number
	last_circular_save	-> last circular save file number
	current_store		-> current store number
	last_store		-> last store number
	current_pbar_shot	-> current pbar shot number
	last_pbar_shot		-> last pbar shot number
	current_recycler_shot	-> current Recycler shot number
	last_recycler_shot	-> last Recycler shot number
	mdat_time		-> current time transmitted over MDAT
	newline			-> newline string (useful in print command)
	tab			-> tab string (useful in print command)
	current_output		-> returns the value of standard output
	current_error		-> returns the value of standard error
	on_linux		-> returns a value of 1 if ACL is being
				   executed on Linux, and value of 0 otherwise

	ACL expressions contain values which may be constants, variables
	or symbols, and device values.  They support operators which
	include the normal arithmetic operators (+, -, *, and /) as well
	as '^' for exponentiation and '%' for integer modulus.  They also
	support logical operators '||' or 'or' and '&&' or 'and'.  They
	support the bitwise operators '|', '&', and 'xor'.  In addition,
	the special device-related operators 'is', 'is not', 'has', and
	'doesnt have' are also supported.  A number of instrinsic functions
	which are listed below are also supported.  Expressions are used
	in the assignment, if, elseif, while, and do_while commands.

	Arithmetic operators:

	addition       : '+', 'plus'
	increment      : '++'
	subtraction    : '-', 'minus'
	decrement      : '--'
	multiplication : '*', 'times'
	division       : '/'
	integer modulus: '%'
	remainder      : '%%'
	exponentiation : '^', '**'
	left shift     : '<<'
	right shift    : '>>'

	Bitwise operators:

	or             : '|', 'bitor'
	exclusive or   : 'xor'
	and            : '&', 'bitand'
	invert         : '~', 'compl', 'complement'

	Logical operators:

	or             : '||', 'or', '.or.'
	exclusive or   : '.xor.'
	and            : '&&', 'and', '.and.'
	negate         : '!', 'not', '.not.'

	Comparison operators:

	equals         : '=', '==', 'equals', 'eq', '.eq.', 'is equal to'
	not equal      : '!=', '<>', 'ne', '.ne.', 'is not equal to', 'does not equal'
	greater than   : '>', 'gt', '.gt.', 'greater than'
	greater/equal  : '>=', 'ge', '.ge.', 'greater than or equal to'
	less than      : '<', 'lt', '.lt.', 'less than'
	less/equal     : '<=', 'le', '.le.', 'less than or equal to'

	Special device operators:

	is             : device is in a particular status (on, off, etc.)
	is not         : device is NOT in a particular status (on, off, etc.)
	has            : device has a particular type of database information
	doesnt have    : device doesn't have a particular type of database information

	Intrinsic functions:

	Arithmetic functions:

	log            : base 10 log
	ln             : natural log
	sqrt           : square root
	sin            : sine
	cos            : cosine
	tan            : tangent
	asin           : arc sine
	acos           : arc cosine
	atan           : arc tangent
	atan2          : arc tangent of the quotient of the arguments
	sinh           : hyperbolic sine
	cosh           : hyperbolic cosine
	tanh           : hyperbolic tangent
	hypot          : square root of the sum of the squares of the arguments
	round          : round
	ceil           : smallest integer greater than or equal to its argument
	floor          : largest integer less than or equal to its argument
	trunc          : truncate
	fmod           : remainder of the arguments
	fract          : fractional component
	abs            : absolute value
	min            : minimum of two values
	max            : maximum of two values
	exp            : base e exponentiation (e^n)

	Bitwise functions:

	or             : bitwise or
	and            : bitwise and
	xor            : bitwise exclusive or
	lshft          : circular left shift
	rshft          : circular right shift
	bit            : bit test

	Array value functions:

	sum            : sum of an array of values
	mean           : mean of an array of values
	median         : median of an array of values
	minimum        : minimum of an array of values
	maximum        : maximum of an array of values
	range          : range of an array of values
	stddev         : standard deviation of an array of values
	rms            : RMS of an array of values
	variance       : varianace of an array of values
	identical      : checks to see if all values in an array are identical

	String funcions:

	head           : returns the beginning of a string
	tail           : returns the end of a string
	substring      : returns a substring of a string
	strncmp        : compares the first n characters of two strings
	trim           : removes leading and trailing blanks from a string
	toupper        : converts a string to upper case
	tolower        : converts a string to lower case
	capitalize     : capitalizes the first character in each word of a string
	tostring       : converts a value to its corresponding string
	to_trimmed_string: converts a value to a string with no spaces
	string_length  : returns the length of a string
	pos            : pads with spaces/truncates a string to a specified
                        length
	pad            : pads a string with a specified character to a specified
                        length
	hex            : returns a value as a hexadecimal string

	Miscellaneous functions:

	exists         : determines if a device or variable/symbol exists
	sizeof         : returns the number of elements in a device or variable
	condif         : returns the second argument if the first has a value
                        of true or the third argument if it has a value of false
	scondif        : returns the second argument as a string if the first
                        has a value of true or the third argument as a string
                        if it has a value of false
	lor            : logical or
	land           : logical and
	random         : returns pseudo random numbers from 0 to 2^31 - 1
	prec           : output precision (eg. prec(value,fraction_digits))
	event_occurred : determines if a clock event has occurred
	time_since_event: returns the elapsed time since an event has occurred
	event_date     : returns the date in clinks when an event last occurred
	timer          : returns the current value of a timer
	node           : converts a node name to a value
	error          : converts an ACNET error string to a value
	device         : converts an ACNET device to a value
	name           : returns a device name string
	full_name      : returns a device full name string
	text           : returns a device descriptive text string
	full_text      : returns a device full descriptive text string
	units          : returns a device units string
	state_text     : returns the text for the current state of a state device
	bit_text       : returns the descriptive text for a specified bit
	bit_data_text  : returns the data text for a specified bit
	analog_alarm_text : returns the analog alarm text for a device
	analog_alarm_priority : returns the analog alarm priority for a device
	digital_alarm_text : returns the digital alarm text for a device
	user_alarm_list: returns the state of a user alarm list
			 (enabled, bypassed, or empty) and can be used in an
			 "is" expression
	settings_are_enabled : determines if settings are enabled
	                       (supports optional device name argument)

	A block of code can be marked so that it is always executed
	regardless of errors or program execution flow.  This is called
	an "always" block.  It must be situated at the end of the script,
	and it is started with a label statement of "always".  The always
	block cannot contain on_error, exit, gosub, goto, or return
	commands.  The always block never affects the overall returned
	status from the script.

-------------------------------------------------------------------------------

	Alphabetic list of ACL commands:

-------------------------------------------------------------------------------

	acnet_request - send an ACNET request
	activate - activate a device
	alarm_limit - read or set analog alarm limits
	alarm_log - display alarm history log
	assignment - assign a value to a variable or symbol
	beam_switch - read the status of a beam switch
	break - jump out of a simple program loop
	bypass - bypass an alarm
	call_proc - execute a non-ACL procedure
	camac - execute individual CAMAC commands
	ch13_message - display the current channel 13 message
	change_device - change the device that a changeable device refers to
	check_status - check the basic status of devices
	clib_info - display CLIB information
	cnswin - move, resize, or iconify a console window
	cns_message - send a console message
	comment_char - disable a comment character
	compare - compare device readings
	console_info - display console information
	continue - jump to the bottom of a simple program loop
	copy - copy one device to another
	copy_variable - copy a value or an array of values into a variable
	cpld_log - display CPLD program log entries
	crate - access CAMAC crate information
	data_event - set the default data event for future data requests
	data_source - establish a data source for future data requests
	dbset - set the database setting record for an ACNET device
	deactivate - deactivate a device
	declare - declare a variable or symbol
	decrement - decrement an ACNET device
	delete - delete cached database information or a file
	delete_cache - delete cached database information
	delta_set - apply a delta to the setting of an ACNET device
	device_arg - specify a description and/or default value for a device
	device_list - specify a list of devices for processing
	digital_control - send a basic control command to a device
	disable - disable a device, a clock event, or another parameter
	download - download the most recent database setting for a device
	downtime_log - display downtime log entries
	do_while - begin a do/while loop
	else - implement default case for a an if/elseif block
	elseif - execute simple nested conditional structure
	enable - enable a device, a clock event, or another parameter
	endif - end a simple conditional structure
	endloop - end a simple program loop
	endwhile - end a simple while loop
	end_do_while - end a do/while loop
	error_text - display ACNET error text
	event_info - display clock event information
	event_log - display event log entries
	exit - end the script
	exitloop - jump out of a simple program loop
	fft - perform an FFT on a set of points
	file_info - display flat file information
	fill - fill a device setting with a value
	find_program - find running instances of a program
	fit - perform a polynomial, exponential, or Gaussian fit on a set of points
	fshare_info - display Filesharing file information
	ftd - set the default Frequency Time Descriptor for future data requests
	ftp - copy a file or files using file transfer protocol (FTP)
	ftp_read - read ACNET device using the fast time plot protocol
	gas - read or write GAS commands
	gosub - jump to a labeled subroutine
	goto - jump to a given label
	gpib - execute GPIB commands
	host_request - pass a request to the host program
	if - execute simple conditional structure
	image_draw - display a graphic image
	increment - increment an ACNET device
	input - define a data input
	list - list device parameters
	list_strings - displays control system lists of strings
	lock - lock a script
	logger_get - read datalogger values
	log_device - log a device value
	loop - execute a simple program loop
	madc - access MADC information
	mail - mail a file to a user
	mdat_info - display MDAT frame information
	negative - set an ACNET device to negative polarity
	node - perform operations on an ACNET node
	node_info - display ACNET node information
	nominal_mask - read or set digital alarm nominals/masks
	off - turn off an ACNET device
	off_list - turn off a list of ACNET devices
	on - turn on an ACNET device
	on_error - establish an error handling routine
	on_list - turn on a list of ACNET devices
	output - define the output for future commands
	path - set the default file path
	polarity - set the polarity of an ACNET device
	positive - set an ACNET device to positive polarity
	print - print a line of output
	program_info - display program information
	program_log - display program (shared) log entries
	program_status - retrieve the status of a program instance
	ramp - ramp a setting to a desired value
	read - read an ACNET device and display the value
	read_dir - read the contents of a file directory
	read_field - read an individual field from an ACNET device
	read_file - read all or part of a file
	read_struct - read an ACNET device structure
	reboot - reboot an ACNET node
	reset - reset an ACNET device
	reset_list - reset a list of ACNET devices
	resize - resize (reallocate) an array variable or symbol
	restore - restore an ACNET device setting
	retry - retry a command which has invoked an error handler
	return - return from a subroutine or error handler
	run - run a program
	save - save devices in a save/restore file
	sda_config - display SDA configuration information
	sda_dir - display SDA directory information
	search - search device readings for a pattern
	set - set an ACNET device
	set_field - set an individual field in an ACNET device
	set_list - set a list of ACNET devices
	set_struct - set an ACNET device structure
	setting_log - display setting log entries
	shot_log - make an entry in the Shot Scrapbook
	show - display database information for a device
	slot - access CAMAC slot information
	snap_read - read ACNET device using the snapshot plot protocol
	sort - sort an array of values or an array device
	sql - send a database modification command or read database values
	sr_dir - display save/restore file directory information
	sr_set - set the value for an ACNET device in a save file
	state_log - display state log entries
	stats - perform simple statistics on device readings or a variable
	step_motor - set a stepping motor
	string_arg - specify a description and/or default value for a string
	str_case - change the case of a string
	str_cat - concatenate two strings together
	str_compare - compare two strings
	str_convert - convert a string value
	str_copy - copy one string to another
	str_find - search for one string in another
	str_format - build a formatted string
	str_length - return the length of a string
	str_replace - replace a substring with another
	str_split - split a string into substrings
	str_tail - extract the tail of a string
	str_trim - trim spaces from a string
	substring - extract a substring from a string
	switch_info - display network switch information
	system - execute a system command
	table_device - read or set table device values
	tcp_request - send a TCP/IP request
	timeout - set data acquisition timeout values
	timer - determine time intervals
	timer_event - read or set timer events
	tlg_info - read information about events generated by the TLG
	toggle - toggle a status attribute of an ACNET device
	trigger - trigger a clock event
	turn - turn an ACNET device on or off
	unescape - replace escape characters in a string
	unlock - unlock a script
	url_display - display a URL in a web browser
	user_info - display console user or console node information
	version - display the version of ACL that is being run
	wait - wait for a period of time, an event, a state, or a device
	web_log - make an entry in a web-based log book
	while - execute simple while loop

-------------------------------------------------------------------------------

	ACL Command help:

-------------------------------------------------------------------------------

	read : read an ACNET device and display the value

	read[/{qualifier...}][/output={spec}] {device}{[n]}[/{qualifier...}]

	This command outputs the name of the requested device, it's current
	value, and the corresponding units text.  One or more elements of
	an array device can be displayed.  Note that a device index can be
	supplied rather than a device name.  This command also supports
	an array index notation which allows you to specify the beginning
	and ending array indices (ex. read t:ha11[3:5]).  This command
	also supports family devices and list specifiers (see above).

	Examples of reading command qualifiers:

	scaled			-> read the scaled data (default)
	raw			-> read the raw data in hex
	raw_bs			-> read the raw data in hex (byte swapped)
	raw_ws			-> read the raw data in hex (word swapped)
	dec[imal]		-> read the raw data in decimal
	dec_bs			-> read the raw data in decimal (byte swapped)
	dec_ws			-> read the raw data in decimal (word swapped)
	primary			-> read the data in primary units (volts)
	string (ascii)		-> read raw data as a string (ASCII)
	string_bs		-> read raw data as a string (ASCII)
				   and byte swap it
	ascii_no_nulls		-> read raw data as a string with embedded
				   (but not trailing) nulls replaced with
				   a pipe (|) character
	state			-> read raw data and display as state text
	date			-> read raw data and display as a date string
				   (raw data assumed to be local time in
				    seconds since Jan 1, 1970)
	date_gmt		-> read raw data and display as a date string
				   (raw data assumed to be GMT (UTC) time in
				    seconds since Jan 1, 1970)
	date_clinks		-> read raw data and display as a date string
				   (raw data assumed to be local time in
				    seconds since Jan 1, 1972)
	acnet_error		-> read raw data and display as an ACNET
				   error string
	node			-> request ACNET node string (raw data assumed
				   to be an ACNET node value)
	property=analog_alarm	-> read whether or not the device is in alarm
	setting			-> read the setting value
	ftd_oneshot		-> request a one shot reading
	length=2		-> request 2 bytes of data
	atomic_size		-> request the atomic size for this property
	maximum_size		-> request the maximum size for this property
	num_elements=4		-> request 4 values
	num_values=4		-> request 4 values
	num_elements=all	-> request all values for this property
	all_elements		-> request all values for this property
	offset=0		-> request data starting at a byte offset of 0
	index=2			-> request data starting at array index 2
	array_index=2		-> request data starting at array index 2
	bit_status		-> request device bitwise status
	state_text		-> request state text data (state devices only)
	source=dp		-> display data from the accelerator (default)
	source=db		-> display data from the database
	source=sr:1		-> display data from save/restore file 1
	source=sda:1:"Inject Protons":1:ColliderShot	-> display data from SDA
							   file 1, case Inject Protons,
							   subcase (set) 1,
							   usage ColliderShot
	source=dl:"01-JAN-2000 01:00"	-> display data from a Lumberjack at
					   January 1, 2000 at 0100
	source=memory		-> display data from a memory pool
	family			-> read an entire family
	whole(all)		-> indicates that you want to read the whole
				   property (only valid when used with 'family')
	row			-> display values in a single row
	column			-> display values in a single column
	no_name			-> don't display device name(s)
	nodisplay		-> don't display the reading, only errors
	waitnew			-> wait for a new value to be returned (default)
	nowaitnew		-> don't wait for a new value to be returned
	pendwait		-> wait for a nonpending status
	ignore_errors		-> display the data even if it is in error
	num_values={variable}	-> saves the number of values read in a variable
	values={array variable}	-> saves the values read in a variable
	dynamic[_arrays]	-> dynamically reallocate output value variable
				   to match the number of values read
	output={spec}		-> specify output destination

	Examples of output specifications:

	mail:{user_name}	 -> send mail to a user
	file:{file_name}	 -> send output to a file
	binary:{file_name}	 -> send output to a binary file
	variable:{variable_name} -> send output to a variable
	symbol:{symbol_name}	 -> send output to a symbol

	The supported properties for this command are:

	reading, setting, basic status, analog alarm, digital alarm

	Examples:

	read z:acltst
	read z:acltst/output=symbol:symbol1
	read z:acltst/raw
	read z:acltst/source=db
	read 27235				! make reading from device index
	read v:cldrst/state
	read g:0b29v0/string/all
	read t_ha11[3:5]			! read elements 3, 4, and 5
	read z:acltst[]				! read an entire array device
	read/family/all z:acltsz		! read a family device
	read node=tev/crate=A1/prread
	read/pendwait m:outtmp/ftd=evt02	! wait for data on event 02
	read m:outtmp/src=sr:last_big_save	! read from last big save
	read m:outtmp/src=dl:"01-JAN-2000 01:00" ! read from data logger
	read m:outtmp/src=sda:1:"Inject Protons":1:ColliderShot
	read m:outtmp.min			! read alarm minimum

	Related commands:

	set, alarm_limit, nominal_mask, list, show, compare
	data_event, ftd, data_source, device_list

-------------------------------------------------------------------------------

	set : set an ACNET device

	set[/{qualifier}] {device}{[n]}[/{qualifier...}] {constant|variable|symbol}

	The constant value is either a numeric constant in the case
	of the setting property or a basic control string in the case
	of the basic control property.  For the setting property,
	multiple scaled or raw values can be supplied.  If multiple
	values are entered, they should be separated by spaces or
	commas.  If a string value is supplied, it should be enclosed
	in either single or double quotes.  Setting values can also be
	supplied in a delimited text file.  This command also supports
	an array index notation which allows you to specify the beginning
	and ending array indices (ex. set z:acltst[1:2]=13,3.5).  This
	command also supports family devices and list specifiers (see above).
	Use of this command may require special privileges.  See Brian
	Hendricks (hendricks@fnal.gov) for more information.

	Examples of setting command qualifiers:

	scaled (common)		-> make a scaled (common) setting (default)
	raw			-> make a raw setting
	primary (volts)		-> make a setting in primary (volts) units
	string			-> make a setting with a string
	state			-> make a setting with state text
				   (state devices only)
	length=2		-> set 2 bytes of data
	atomic_size		-> set the atomic size for this property
	maximum_size		-> set the maximum size for this property
	num_elements=4		-> set 4 values
	num_values=4		-> set 4 values
	all			-> set all values for this property
	all_elements		-> set all values for this property
	offset=0		-> set data starting at a byte offset of 0
	index=2			-> set data starting at array index 2
	array_index=2		-> set data starting at array index 2
	source=memory		-> set data in a memory pool
	[alarm_]minimum		-> set the analog alarm minimum
	[alarm_]maximum		-> set the analog alarm maximum
	min_max			-> set the analog alarm minimum and maximum
	analog_nominal		-> set the analog alarm nominal
	analog_alarm_nominal	-> set the analog alarm nominal
	[alarm_]tolerance	-> set the analog alarm tolerance
	nom_tol			-> set the analog alarm nominal and tolerance
	[alarm_]nominal		-> set the digital alarm nominal
	[alarm_]mask		-> set the digital alarm mask
	[alarm_]tries		-> set the number of alarm tries
	[alarm_]ftd		-> set the alarm scan rate (for MOOC devices)
	limit_type		-> set analog alarm limit type
	init_alarm_flags	-> initialize alarm display/logging flags
	motor			-> set a motor device
	hex			-> setting value is in hexadecimal
	decimal			-> setting value is in decimal (default)
	file			-> read setting values from a file
				   (default file extension is ".dat")
	byte_swap		-> used with a raw setting to swap the setting
				   bytes on word boundaries
	word_swap		-> used with a raw setting to swap the setting
				   words
	family			-> set an entire family

	Examples of control strings:

	reset		-> reset device
	on		-> turn on device
	off		-> turn off device
	toggle_onoff	-> toggle on/off status
	positive	-> set the device to positive polarity
	negative	-> set the device to negative polarity
	toggle_polarity	-> toggle polarity
	ramp		-> set the device to ramp mode
	dc		-> set the device to DC mode
	toggle_rampdc	-> toggle ramp/DC mode
	enable_alarm	-> enable an alarm
	bypass_alarm	-> bypass an alarm
	enable_abort	-> enable an alarm abort flag
	abort_inhibit	-> disable an alarm abort flag
	enable_display	-> enable an alarm display flag
	disable_display	-> disable an alarm display flag
	enable		-> enable a device (frig FSMs and loops only)
	disable		-> disable a device (frig FSMs and loops only)
	activate	-> activate a device (frig and GFSDA FSMs only)
	deactivate	-> deactivate a device (frig and GFSDA FSMs only)

	Examples:

	set z:acltst 5
	set z:acltst $symbol1
	set z:acltst/raw 0xA9
	set z:acltst=1,2,3,4
	set z:acltst[2]/raw 3 4
	set z:acltst[3] 'abcd'
	set t:ha11 reset
	set t:ha11 on
	set m@outtmp enable_alarm		! enable analog alarm
	set m@outtmp/minimum 32			! set alarm minimum
	set m@outtmp/maximum 100		! set alarm maximum
	set v:cdfmod/state 'Colliding Beams On'
	set z:acltst[1:2]=16,3.5
	set z:acltst[]=0,16,3.5,11		! set an entire array
	set z:acltst[2:3]=z:aclts3[1:2]		! set multiple array elements
	set z:acltst[2:3]=array[1]		! set multiple array elements
	set/family z:acltsz[1:2] = 16, 17.5	! set a family device
	set m:outtmp.min = 20			! set alarm minimum

	Related commands:

	read, enable, disable, bypass, activate, deactivate
	turn, reset, toggle, alarm_limit, nominal_mask
	fill, copy, decrement, increment, delta_set, set_field,
	device_list

-------------------------------------------------------------------------------

	change_device : change the device that a changeable device refers to

	change_device[/{qualifier}] {changeable device} [to] {new device}

	This command allows the caller to change which actual device
	that a "changeable" device actually points to.  A changeable
	device has a name of the form "G:CDVnn".

	Examples of change_device command qualifiers:

	{property}		 -> set the property for the device
	property={property}	 -> set the property for the device
	verbose			 -> display verbose output

	Examples:

	change_device g:cdv0 to z:acltst

	declare str string="m:outtmp"
	change_device g:cdv0 to str

	Related commands:

	device_list, read, set

-------------------------------------------------------------------------------

	decrement : decrement an ACNET device

	decrement {device}{[n]}{/qualifier...} {constant|variable|symbol}

	This command decrements a device's setting by a specified amount.
	This command is only valid for a device's setting property.
	This command also supports family devices and list specifiers
	(see above).  Use of this command may require special privileges.
	See Brian Hendricks (hendricks@fnal.gov) for more information.

	Examples of decrement command qualifiers:

	family		-> decrement an entire family
	verbose		-> generate verbose output

	Examples:

	decrement z:acltst 2
	decrement z:acltst $symbol1
	decrement name=z:aclts% .1

	Pseudonyms: dec

	Related commands:

	increment, delta_set, set, device_list

-------------------------------------------------------------------------------

	delete_cache : delete cached database information

	delete_cache [{device}]

	This command will delete cached database information.  If a
	device name is specified, only information for that device
	will be deleted.  Otherwise, all cached database information
	will be deleted.

	(Note: Arguments enclosed in square brackets are optional.)

	Examples:

	delete_cache
	delete_cache z:acltst

	Related commands:

	delete

-------------------------------------------------------------------------------

	delta_set : apply a delta to the setting of an ACNET device

	delta_set {device}{[n]}{/qualifier...} {constant|variable|symbol}

	This command applies a specified delta to a device's setting.
	This command is only valid for a device's setting property.
	This command also supports family devices and list specifiers
	(see above).  Use of this command may require special privileges.
	See Brian Hendricks (hendricks@fnal.gov) for more information.

	Examples of delta_set command qualifiers:

	family		-> apply a delta to an entire family
	verbose		-> generate verbose output

	Examples:

	delta_set z:acltst 2
	delta_set z:acltst $symbol1
	delta_set name=z:aclts% -.1

	Pseudonyms: deltaset

	Related commands:

	increment, decrement, set, device_list

-------------------------------------------------------------------------------

	device_list : specify a list of devices for processing

	device_list/[/{qualifier}] {name} [{list}={list_specifier}]

	This command allows the user to specify a list of devices
	which can later be accessed one at a time through a pseudo
	device name of "Q:xxxxxx" where xxxxxx is the name given
	to the list.  The lists of devices are established through
	the use of any of the standard ACL list specifiers.  List
	names must consist of from 1 to 6 characters.  This command
	also allows the caller to increment or decrement through
	the list.  Care should be taken in the use of device lists
	to make sure to specify property values in the event that
	the list is used in a context where properties must be
	specified.  Either specify the property explicitly in this
	command or choose the mutable_property option so that the
	property can be selected by the context.

	Examples of device_list qualifiers:

	create			-> creates a device list
	inc[rement]		-> increments to point to the next device
				   in the list
	dec[rement]		-> decrements to point to the previous device
				   in the list
	rewind			-> resets the list pointer to the beginning
				   of the list
	set_index={index}	-> sets the list pointer to a specific index
	size (length)		-> outputs the number of devices in the list
	delete			-> deletes an existing device list
	{property}		-> specifies the default property for devices
				   in the list
	property={property}	-> specifies the default property for devices
				   in the list
	event={event value}	-> specifies a time since event timer
	autoinc			-> specifies that the list pointer should be
				   automatically incremented each time the
				   list is accessed
	dont_cull		-> don't cull devices from the list which
				   don't have the requested property
	cache={prop1,prop2,...}	-> establish properties which should have
				   their database information cached for
				   more efficient execution
	sort={sort type}	-> sort the devices in a particular order
				   (name_asc, name_desc, di_asc, or di_desc)
	output={spec}		-> specify output destination

	Special device qualifiers for device_list:

	mutable_property	-> indicates that the properties used for
				   the devices can be changed at use time
	mutable_length_offset	-> indicates that the lengths and/or offsets
				   used for the devices can be changed at
				   use time
	mutable_data_source	-> indicates that the data source used for
				   the devices can be changed at use time
	mutable_access_type	-> indicates that the access type used for
				   the devices can be changed at use time

	Examples:

	device_list/create fg devices='z_aclts2,z_aclts3'	! create list
	loop 2 cnt=0
	print name(q:fg) ' = ' q:fg
	device_list/inc fg
	endloop

	device_list/create/read fg name=m:out%	! create list
	device_list/size/output=variable:list_length fg
	loop list_length
	logger_get/start=thismin/node=fastest q:fg
	device_list/inc fg
	endloop

	device_list/create/read fg file=device_file.txt	! create list from file

	Related commands:

	read, set, show, logger_get, ramp

-------------------------------------------------------------------------------

	download : download the most recent database setting for a device

	download[/{qualifier}] {device}{[n]}[/{qualifier...}]

	This command will restore a setting value to the value it
	has in the settings database.  This command can be used for the
	setting, analog alarm, and digital alarm properties.  This command
	also supports an array index notation which allows you to specify
	the beginning and ending array indices (ex. download z:acltst[1:2]).
	This command also supports family devices and list specifiers
	(see above).  Use of this command may require special privileges.
	See Brian Hendricks (hendricks@fnal.gov) for more information.

	Examples of download command qualifiers:

	family		-> download an entire family
	verbose		-> generate verbose output
	init		-> initial download (used for alarm blocks only to
			   make sure that they start out disabled and with
			   display enabled)

	Examples:

	download z:acltst		! download the entire property
	download z:acltst[1:2]
	download m@outtmp		! download an analog alarm block
	download node=pnut01
	download/init m@outtmp		! download initialized analog alarm
	download/init t$ha11		! download initialized digital alarm

	Related commands:

	restore, set, device_list

-------------------------------------------------------------------------------

	increment : increment an ACNET device

	increment {device}{[n]}{/qualifier...} {constant|variable|symbol}

	This command increments a device's setting by a specified amount.
	This command is only valid for a device's setting property.
	This command also supports family devices and list specifiers
	(see above).  Use of this command may require special privileges.
	See Brian Hendricks (hendricks@fnal.gov) for more information.

	Examples of increment command qualifiers:

	family		-> increment an entire family
	verbose		-> generate verbose output

	Examples:

	increment z:acltst 2
	increment z:acltst $symbol1
	increment name=z:aclts% .1

	Pseudonyms: inc

	Related commands:

	decrement, delta_set, set, device_list

-------------------------------------------------------------------------------

	fill : fill a device setting with a value

	fill[/{qualifier}] {device}{[n]}[/{qualifier...}] {constant|variable|symbol}

	This command will fill the requested number of values in a
	setting property with the same value.  This command also supports
	an array index notation which allows you to specify the beginning
	and ending array indices (ex. fill z:acltst[1:2]=16.1).
	This command also supports family devices and list specifiers
	(see above).  Use of this command may require special privileges.
	See Brian Hendricks (hendricks@fnal.gov) for more information.

	Examples of fill command qualifiers:

	scaled (common)	-> make a scaled (common) setting (default)
	raw		-> make a raw setting
	primary (volts)	-> make a setting in primary (volts) units
	length=2	-> set 2 bytes of data
	atomic_size	-> set the atomic size for this property
	maximum_size	-> set the maximum size for this property
	num_elements=4	-> set 4 values
	num_values=4	-> set 4 values
	all		-> set all values for this property
	all_elements	-> set all values for this property
	offset=0	-> set data starting at a byte offset of 0
	index=2		-> set data starting at array index 2
	array_index=2	-> set data starting at array index 2
	hex		-> setting value is in hexadecimal
	decimal		-> setting value is in decimal (default)

	Examples:

	fill z:acltst 5
	fill z:acltst $symbol1
	fill z:acltst/raw 0xA9
	fill z:acltst[2]/raw 3
	fill z:acltst[2]/num_values=2 16
	fill z:acltst[1:2]=16.1

	Related commands:

	set, copy

-------------------------------------------------------------------------------

	digital_control : send a basic control command to a device

	digital_control[/{qualifier}] {device|devicelist} {command}

	This command supports sending any basic control command to
	one or more devices.  It is only valid for a device's basic
	control property.  This command also supports family devices
	and list specifiers (see above).  Use of this command may
	require special privileges.  See Brian Hendricks
	(hendricks@fnal.gov) for more information.

	Examples of digital_control command qualifiers:

	family		-> turn on an entire family
	verbose		-> generate verbose output

	Examples:

	digital_control i:q701 on

	Related commands:

	on, on_list, off, off_list, reset, reset_list, positive, negative,
	polarity, set, turn, toggle, device_list

-------------------------------------------------------------------------------

	negative : set an ACNET device to negative polarity

	negative[/{qualifier}] {device}{[n]}{/qualifier...}

	This command supports setting one or more devices to negative
	polarity.  It is only valid for a device's basic control property.
	This command also supports family devices and list specifiers
	(see above).  Use of this command may require special privileges.
	See Brian Hendricks (hendricks@fnal.gov) for more information.

	Examples of negative command qualifiers:

	check[_status]	-> only set the device to a negative polarity
			   if it's not already in negative polarity
	family		-> set an entire family to negative polarity
	verbose		-> generate verbose output

	Examples:

	negative i:q701

	Related commands:

	polarity, positive, on, off, reset, set, turn, toggle, digital_control,
	device_list

-------------------------------------------------------------------------------

	off : turn off an ACNET device

	off[/{qualifier}] {device}{[n]}{/qualifier...}

	This command supports turning off one or more devices.  It is only
	valid for a device's basic control property.  This command also
	supports family devices and list specifiers (see above).  
	Use of this command may require special privileges.  See Brian
	Hendricks (hendricks@fnal.gov) for more information.

	Examples of off command qualifiers:

	check[_status]	-> only turn off the device if it's not off
	family		-> turn off an entire family
	verbose		-> generate verbose output

	Examples:

	off i:q701

	Related commands:

	off_list, on, on_list, reset, reset_list, positive, negative,
	polarity, set, turn, toggle, digital_control, device_list

-------------------------------------------------------------------------------

	off_list : turn off a list of ACNET devices

	off_list[/{qualifier}] {device}|device_list={list}{[n]}{/qualifier...}

	This command supports turning off one or more devices.  This command
	supports family devices and list specifiers (see above).  Use of this
	command may require special privileges.  See Brian Hendricks
	(hendricks@fnal.gov) for more information.

	Examples of off_list command qualifiers:

	family		-> turn on an entire family
	verbose		-> generate verbose output

	Examples:

	device_list/create devs devices='z:acltst,z:aclts5,z:aclts6'/control
	off_list device_list=devs

	Related commands:

	off, on, on_list, reset_list, positive, negative, polarity, set,
	turn, toggle, digital_control, device_list

-------------------------------------------------------------------------------

	on : turn on an ACNET device

	on[/{qualifier}] {device}{[n]}{/qualifier...}

	This command supports turning on one or more devices.  It is only
	valid for a device's basic control property.  This command also
	supports family devices and list specifiers (see above).  
	Use of this command may require special privileges.  See Brian
	Hendricks (hendricks@fnal.gov) for more information.

	Examples of on command qualifiers:

	check[_status]	-> only turn on the device if it's not on
	reset		-> reset the device before giving it an on command
	family		-> turn on an entire family
	verbose		-> generate verbose output

	Examples:

	on i:q701

	Related commands:

	on_list, off, off_list, reset, reset_list, positive, negative,
	polarity, set, turn, toggle, digital_control, device_list

-------------------------------------------------------------------------------

	on_list : turn on a list of ACNET devices

	on_list[/{qualifier}] {device}|device_list={list}{[n]}{/qualifier...}

	This command supports turning on one or more devices.  This command
	supports family devices and list specifiers (see above).  Use of this
	command may require special privileges.  See Brian Hendricks
	(hendricks@fnal.gov) for more information.

	Examples of on_list command qualifiers:

	reset		-> reset the device before giving it an on command
	family		-> turn on an entire family
	verbose		-> generate verbose output

	Examples:

	device_list/create devs devices='z:acltst,z:aclts5,z:aclts6'/control
	on_list device_list=devs

	Related commands:

	on, off, off_list, reset_list, positive, negative, polarity, set,
	turn, toggle, digital_control, device_list

-------------------------------------------------------------------------------

	polarity : set the polarity of an ACNET device

	polarity[/{qualifier}] {pos|neg} {device}{[n]}{/qualifier...} {pos|neg}

	This command supports setting the polarity of one or more devices.
	The specific command value can be placed before or after the device.
	This command is only valid for a device's basic control property.
	This command also supports family devices and list specifiers
	(see above).  Use of this command may require special privileges.
	See Brian Hendricks (hendricks@fnal.gov) for more information.

	Examples of polarity command qualifiers:

	toggle		-> toggle the polarity
	family		-> control an entire family
	verbose		-> generate verbose output

	Examples:

	polarity t:ozf positive
	polarity positive t:ozf
	polarity t:ozf negative
	polarity negative t:ozf
	polarity toggle t:ozf

	Related commands:

	positive, negative, turn, on, off, set, toggle, reset, digital_control,
	device_list

-------------------------------------------------------------------------------

	positive : set an ACNET device to positive polarity

	positive[/{qualifier}] {device}{[n]}{/qualifier...}

	This command supports setting one or more devices to positive
	polarity.  It is only valid for a device's basic control property.
	This command also supports family devices and list specifiers
	(see above).  Use of this command may require special privileges.
	See Brian Hendricks (hendricks@fnal.gov) for more information.

	Examples of positive command qualifiers:

	check[_status]	-> only set the device to a positive polarity
			   if it's not already in positive polarity
	family		-> set an entire family to positive polarity
	verbose		-> generate verbose output

	Examples:

	positive i:q701

	Related commands:

	polarity, negative, on, off, reset, set, turn, toggle, digital_control,
	device_list

-------------------------------------------------------------------------------

	ramp : ramp a setting to a desired value

	ramp[/time={secs}] {device}{[n]}[/{qualifier...}] {constant|variable|symbol}

	This command will ramp a setting value from its present value
	to the requested value.  If no ramp duration is specified,
	a ramp duration of zero will be used.  In this case, the ramp
	command functions like the set command.  This command can also
	be used to ramp a setting using a fixed step size and delay
	between settings.  This command can also be configured for
	ramping back to the original value.  Use of this command may
	require special privileges.  See Brian Hendricks (hendricks@fnal.gov)
	for more information.

	Examples of ramp command qualifiers:

	time={secs}		-> ramp duration in seconds
	duration={secs}		-> ramp duration in seconds
	step_size={size}	-> constant ramp step size
	step_delay={msecs}	-> delay between successive settings in
				   milliseconds
	flattop_length={secs}	-> number of seconds to wait before ramping
				   back to the original setting value
	ramp_back		-> ramp back to the original setting value
	max_step_size={maxstep}	-> maximum allowable step size
				   (only used in ramp by time method)
	monitor_device={device}	-> device to monitor the status of the ramp
				   (primarily useful for certain types of
				    stepper motor devices)
	scaled (common)		-> make a scaled (common) setting (default)
	raw			-> make a raw setting
	primary (volts)		-> make a setting in primary (volts) units
	offset=0		-> set data starting at a byte offset of 0
	index=2			-> set data starting at array index 2
	array_index=2		-> set data starting at array index 2

	Examples:

	ramp/time=2 z:acltst 5
	ramp/time=2 z:acltst to 5
	ramp z:acltst = 5 /time=2
	ramp/time=2 z:acltst $symbol1
	ramp/duration=2 z:acltst/raw 0xA9
	ramp/duration=2 z:acltst[2] 16
	ramp/duration=2/flattop_length=1 z:acltst[2] 16
	ramp/step_size=0.01 z:aclts3 to 2

	Related commands:

	increment, decrement, delta_set, set, device_list

-------------------------------------------------------------------------------

	read_field : read an individual field from an ACNET device

	read_field[/{qualifier}] {device}{[n]}[/{qualifier...}]

	This command is primarily used to read fields in a device's
	setting property that are otherwise indivisible by the control
	system.  An example of this would be a time table entry in a
	waveform generator.  This command discards the portion of the
	setting field that is not being read.  This command also supports
	an array index notation which allows you to specify the beginning
	and ending array indices (ex. read_field z:acltst[1:2]).  This
	command also supports family devices and list specifiers (see above).

	Examples of read_field command qualifiers:

	scaled (common)		-> make a scaled (common) reading
				   (default and only available if field offset
				    is zero))
	raw			-> make a raw reading
				   (default if field offset is nonzero)
	primary (volts)		-> make a reading in primary (volts) units
	offset={offset}		-> field offset in bytes
	length={length}		-> field length in bytes
	source=memory		-> read data in a memory pool
	hex			-> display values in hexadecimal
	dec[imal]		-> display values in decimal (default)
	byte_swap		-> used with a raw reading to swap the reading
				   bytes on word boundaries
	word_swap		-> used with a raw reading to swap the reading
				   words
	family			-> read an entire family
	row			-> display values in a single row
	column			-> display values in a single column
	nodisplay		-> don't display the reading, only errors
	waitnew			-> wait for a new value to be returned (default)
	nowaitnew		-> don't wait for a new value to be returned
	pendwait		-> wait for a nonpending status
	timeout={seconds}	-> set reading timeout in seconds
	ignore_errors		-> display the data even if it is in error
	read_value={variable}	-> variable to hold reading data
	dynamic[_arrays]	-> dynamically reallocate output data variables
				   to match the number of values read
	output={spec}		-> specify output destination

	Examples:

	read_field/length=2 s_4530t[2]
	read_field/offset=2/dec s_4530t[2]
	read_field/offset=2/dec s_4530t[2:3]		! read two values

	Related commands:

	set_field, read, read_struct, set, device_list

-------------------------------------------------------------------------------

	read_struct : read an ACNET device structure

	read_struct[/{qualifier}] {device}{[n]}[/{qualifier...}]

	This command is used to read back ACNET device data as a structure.
	The structure of the data can be explicitly defined in the command
	itself or a named structure can be specified.  This command also
	supports an array index notation which allows you to specify the
	beginning and ending array indices (ex. read_struct z:acltst[1:2]).
	This command also supports family devices and list specifiers
	(see above).

	Examples of read_struct command qualifiers:

	struct[ure]={name}		-> specify a named structure
	reading={type}={value},...	-> reading structure specification
	read_string			-> read data as a string
	reading_length={bytes}		-> specified the number of bytes to read
	source=memory			-> read data in a memory pool
	ieee_to_dec			-> convert IEEE floats to DEC
	hex				-> display values in hexadecimal
	dec[imal]			-> display values in decimal (default)
	byte_swap			-> used with a raw reading to swap the
					   reading bytes on word boundaries
	word_swap			-> used with a raw reading to swap the
					   reading words
	family				-> read an entire family
	nodisplay			-> don't display the reading,
					   only errors
	waitnew				-> wait for a new value to be returned
					   (default)
	nowaitnew			-> don't wait for a new value to be
					   returned
	pendwait			-> wait for a nonpending status
	timeout={seconds}		-> set reading timeout in seconds
	ignore_errors			-> display the data even if it is
					   in error
	read_values={var,...}		-> variable(s) to hold reading data
					   (one per field of the structure)
	dynamic[_arrays]		-> dynamically reallocate output data
					   variables to match the number
					   of values read
	output={spec}			-> specify output destination

	Examples:

	read_struct/struct=bpm_data r:bp1cov

	Related commands:

	read_field, read, device_list, set_struct

-------------------------------------------------------------------------------

	restore : restore an ACNET device setting

	restore {device}{[n]}[/{qualifier...}] [from] {source}[:{arg1}:{arg2}:{arg3}:{arg4}]

	This command will restore a setting value to the value it
	had in either the database, a save/restore file, an SDA file,
	a data logger (Lumberjack), or a memory pool.  If no length or
	offset is specified, the entire property will be restored.
	This command can be used for the setting, basic status,
	analog alarm, and digital alarm properties.  This command also
	supports an array index notation which allows you to specify
	the beginning and ending array indices
	(e.g.. restore z:acltst[1:2] from db).  This command also supports
	family devices and list specifiers (see above).  Use of this
	command may require special privileges.  See Brian Hendricks
	(hendricks@fnal.gov) for more information.

	Type		Syntax
	----		------
	database	db
	save/restore	sr:{file number}
	SDA		sda:{file number}:{case}[:{subcase}:{usage}]
	data logger	dl:{start date}[:{node}:{accuracy in seconds}]
	memory		memory[:{pool_name|pool_id}]

	(Note: Arguments enclosed in square brackets are optional.)

	Examples of restore command qualifiers:

	family				-> restore an entire family
	verbose				-> generate verbose output
	props=all			-> restore all restorable properties
	props=prop1:prop2:prop3:prop4	-> restore specific properties
	save_properties_only		-> used in conjunction with "props"
					   to limit each device to properties
					   that are indicated in its save
					   property
	motor				-> restore a motor's position
	ignore_save_info		-> ignore any database save information
					   and perform a default restore

	Relevant special constants:

	last_linac_save			-> newest Linac save file
	last_booster_save		-> newest Booster save file
	last_mi_save			-> newest Main Injector save file
	last_tev_save			-> newest Tevatron save file
	last_extbeams_save		-> newest external beams save file
	last_pbar_save			-> newest Pbar save file
	last_recycler_save		-> newest Recycler save file
	last_misc_save			-> newest miscellaneous save file
	last_big_save			-> newest big save file
	last_shot_save			-> newest shot save file
	last_circular_save		-> newest circular save file
	last_miniboone_save		-> newest MiniBooNE save file

	Examples:

	restore z:acltst from db
	restore z:acltst sr:1
	restore z:acltst from sda:1:"Inject Protons":1:ColliderShot
	restore z:acltst dl:"01-Jan-2000 00:00":fastest:3600
	restore z:acltst[1:2] from sr:1
	restore/props=all node=pnut01 from sr:last_big_save
	restore/props=setting:status node=pnut01 from sr:last_big_save

	Related commands:

	save, download, copy, set, fill, device_list

-------------------------------------------------------------------------------

	save : save devices in a save/restore file

	save[/{qualifier}] {file number} ['{title}'] {parameters to save}

	This command will save devices in a save/restore file or in a
	memory pool.  Individual devices, family devices, and/or any of
	the list specifications (see above) that ACL supports can be saved.
	If there are multiple items to be saved, they should be separated
	by commas.  Specific save files in the 900, 1100, and 1200 ranges
	can not be selected since file numbers in these ranges are
	automatically selected by the BIGSAV and SCHSAV processes.  If a
	title is not specified, a generic title will be used.  Use of this
	command may require special privileges.  See Brian Hendricks
	(hendricks@fnal.gov) for more information.

	Examples of save command qualifiers:

	verbose				-> generate verbose output
	operator			-> save file with operator protection
	file={file number}		-> specify save file number
	title="{title}"			-> specify file title
	items={item1,item2,...}		-> specify items to save
	protect={protection}		-> specify file protection
					   (none (default), operator, archive)
	memory[={pool}|{id}]		-> save values in a memory pool
	props=all			-> save all savable properties
					   (memory saves only)
	props=prop1:prop2:prop3:prop4	-> save specific properties
					   (memory saves only)
	save_properties_only		-> used in conjunction with "props"
					   to limit each device to properties
					   that are indicated in its save
					   property
	node={node}			-> node to send save request to
	wait_for_save			-> wait for current save to complete
					   if one is in progress
	no_send				-> inhibit the actual save
	check_status			-> check to see if a save is in progress
					   ($_value will be to a value of 1 if
					    a save is in progress or a value of
					    0 otherwise.)
	cancel				-> cancel the current save
	verbose				-> display verbose command status

	Relevant special constants:

	oldest_linac_file		-> oldest Linac save file
	oldest_booster_file		-> oldest Booster save file
	oldest_mi_file			-> oldest Main Injector save file
	oldest_tev_file			-> oldest Tevatron save file
	oldest_extbeams_file		-> oldest external beams save file
	oldest_pbar_file		-> oldest Pbar save file
	oldest_recycler_file		-> oldest Recycler save file
	oldest_misc_file		-> oldest miscellaneous save file
	oldest_miniboone_file		-> oldest MiniBooNE save file

	Examples:

	save 821 "test save" z:acltst,z:aclts2
	save oldest_booster_file "test save" user_save_list=booster\400_mev\vert
	save 821 "test save" node=baker,node=ap1001
	save 821 "test save" query=name="m:out%"
	save/file=821/title="test save"/items="family=t:horzfg,query='name=t:h*'"
	save/memory query='name=t:ha*'

	Related commands:

	restore, download, set

-------------------------------------------------------------------------------

	set_field : set an individual field in an ACNET device

	set_field[/{qualifier}] {device}{[n]}[/{qualifier...}] {constant|variable|symbol}

	This command is primarily used to set fields in a device's
	setting property that are otherwise indivisible by the control
	system.  An example of this would be a time table entry in a
	waveform generator.  This command preserves the portion of the
	setting field that is not being changed.  Multiple scaled or
	raw values can be supplied for the setting.  If multiple
	values are entered, they should be separated by spaces or
	commas.  Setting values can also be supplied in a delimited
	text file.  This command also supports an array index notation
	which allows you to specify the beginning and ending array indices
	(ex. set z:acltst[1:2]=13,3.5).  This command also supports family
	devices and list specifiers (see above).  Use of this command may
	require special privileges.  See Brian Hendricks (hendricks@fnal.gov)
	for more information.

	Examples of set_field command qualifiers:

	scaled (common)		-> make a scaled (common) setting
				   (default and only available if field offset
				    is zero))
	raw			-> make a raw setting
				   (default if field offset is nonzero)
	primary (volts)		-> make a setting in primary (volts) units
	offset={offset}		-> field offset in bytes
	length={length}		-> field length in bytes
	source=memory		-> set data in a memory pool
	hex			-> setting value is in hexadecimal
	dec[imal]		-> setting value is in decimal (default)
	file			-> read setting values from a file
				   (default file extension is ".dat")
	byte_swap		-> used with a raw setting to swap the setting
				   bytes on word boundaries
	word_swap		-> used with a raw setting to swap the setting
				   words
	family			-> set an entire family

	Examples:

	set_field/length=2 s:4530t[2] 5
	set_field/offset=2/dec s:4530t[2] 100
	set_field/offset=2/dec s:4530t[2] 100, 100	! set two values
	set_field/length=2 s:4530t[2] $symbol1

	Related commands:

	read_field, set, read, enable, disable, bypass, activate, deactivate
	turn, reset, toggle, alarm_limit, nominal_mask
	fill, copy, decrement, increment, delta_set, device_list

-------------------------------------------------------------------------------

	set_list : set a list of ACNET devices

	set_list[/{qualifier}] {device}{[n]}[/{qualifier...}] {constant|variable|symbol}

	This command permits the setting of a list of devices
	simultaneously.  Multiple values (either scaled or raw)
	can be set for each device.  If multiple values are entered,
	they should be separated by spaces or commas.  Setting values
	can also be supplied in a delimited text file.  This command
	also supports an array index notation which allows you to
	specify the beginning and ending array indices.  This command
	also supports family devices and list specifiers (see above).
	Use of this command may require special privileges.  See Brian
	Hendricks (hendricks@fnal.gov) for more information.

	Examples of set_list command qualifiers:

	scaled (common)		-> make a scaled (common) setting (default)
	raw			-> make a raw setting
	primary (volts)		-> make a setting in primary (volts) units
	values_per_device={num}	-> specify the number of values to set for
				   each device
	values={val,...}	-> specify the setting values
	hex			-> setting value is in hexadecimal
	decimal			-> setting value is in decimal (default)
	file			-> read setting values from a file
				   (default file extension is ".dat")
	byte_swap		-> used with a raw setting to swap the setting
				   bytes on word boundaries
	word_swap		-> used with a raw setting to swap the setting
				   words

	Examples:

	device_list/create devs devices='z:aclts5,z:aclts6,z:aclts7'
	declare vals={1,2,3}
	set_list device_list=devs vals

	device_list/create devs devices='z:aclts5,z:aclts6,z:aclts7'
	set_list device_list=devs 1,2,3

	Related commands:

	set, set_field, read, device_list, declare, fill, copy,
	decrement, increment, delta_set

-------------------------------------------------------------------------------

	set_struct : set an ACNET device structure

	set_struct[/{qualifier}] {device}{[n]}[/{qualifier...}]={{type}={value},...}

	This command is used to set ACNET device data as a structure.
	The structure of the data can be explicitly defined in the command
	itself or a named structure can be specified.  This command also
	supports an array index notation which allows you to specify the
	beginning array index (ex. set_struct r_bp1acq[1]).
	This command also supports family devices and list specifiers
	(see above).

	Examples of set_struct command qualifiers:

	struct[ure]={name}		-> specify a named structure
	setting={{type}={value},...}	-> setting structure specification
	fill={fill method}		-> can be used with a named structure
					   to initialize the setting buffer
					   from the device reading or from the
					   structure default values
	reading_fill			-> initialize the setting buffer
					   from the device reading
	default_fill			-> initialize the setting buffer
					   from the structure default values
	file				-> read structure information from
					   a file
	ieee_to_dec			-> convert IEEE floats to DEC
	dec_to_ieee			-> convert DEC floats to IEEE
	byte_swap			-> swap the setting bytes on word
					   boundaries
	word_swap			-> swap the setting words on longword
					   boundaries
	family				-> set an entire family
	output={spec}			-> specify output destination

	Examples:

	set_struct/struct='recycler bpm acquisition spec'/ieee/word_swap\
	/reading_fill g_dev0 = {'arm event'=0x29,'trigger event'=0xda}

	set_struct/ieee/word_swap g_dev0 = \
	{int=0,int=1,int=2,int=0,int=0,int=0x29,int=0xda,int=0,int=100,\
	int=0,float=0.0,int=300}	! use specified data types and values

	Related commands:

	set_field, set, device_list, read_struct

-------------------------------------------------------------------------------

	sort : sort an array of values or an array device

	sort[/{qualifier}] {variable|device}{[n]}[/{qualifier...}]

	This command is used to sort the values in an array variable or
	the values in an array device.  Sorts can be either ascending or
	descending.  For some data types such as device index, node, error,
	and event, the sorts can even be done on the ASCII form of the
	values (e.g. 27235 -> M:OUTTMP).  The sorts are done in place for
	variables.  For sorts of both variables and devices, the sorted
	array can be output to another array variable.  This command
	also supports an array index notation which allows you to specify
	the beginning and ending array indices (ex. sort z:acltst[0:3]).
	This command also supports family devices and list specifiers
	(see above).

	Examples of sort command qualifiers:

	asc[ending]		-> ascending sort (default)
	ascii_asc[ending]	-> ascending ASCII sort
	desc[ending]		-> descending sort
	ascii_desc[ending]	-> descending ASCII sort
	num_values={variable}	-> returned number of values value
	values={values}		-> either the input array variable
				   or the returned sorted device values
	family			-> read an entire family
	waitnew			-> wait for a new value to be returned (default)
	nowaitnew		-> don't wait for a new value to be returned
	pendwait		-> wait for a nonpending status
	timeout={seconds}	-> set reading timeout in seconds
	dynamic[_arrays]	-> dynamically reallocate output data variables
				   to match the number of values read
	verbose			-> verbose output
	output={spec}		-> specify output destination

	Examples:

	declare strings string[3]="bob","al","kevin"
	sort strings				! array of strings

	declare floats float[3]=2,3,1
	sort/desc strings			! array of floats

	declare floats float[1]
	sort/desc/dynamic/values=floats z:acltst	! array device

	Related commands:

	stats, fit, read

-------------------------------------------------------------------------------

	stats : perform simple statistics on device readings or a variable

	stats[/{qualifier}] [{device|identifier}{[n]}[/{qualifier...}]]

	This command is used to perform simple statistics on device readings
	from either the reading or setting property or an array variable.
	Device readings can either come from a list of devices or from a
	single array device.  The resultant values are displayed by default.
	They can also optionally be deposited into variables.  This command
	also supports an array index notation which allows you to specify
	the beginning and ending array indices (ex. stats z:acltst[1:2]).
	This command also supports family devices and list specifiers
	(see above).

	Examples of stats command qualifiers:

	num_values={variable}	-> returned number of values value
	values={values}		-> either the input array variable
				   or the returned device values used
				   in the calculations
	sum={variable}		-> returned sum value
	mean={variable}		-> returned mean value
	median={variable}	-> returned median value
	stddev={variable}	-> returned standard deviation value
	rms={variable}		-> returned RMS value
	minimum={variable}	-> returned minimum value
	maximum={variable}	-> returned maximum value
	range={variable}	-> returned range value
	variance={variable}	-> returned variance value
	family			-> read an entire family
	nodisplay		-> don't display the reading, only errors
	waitnew			-> wait for a new value to be returned (default)
	nowaitnew		-> don't wait for a new value to be returned
	pendwait		-> wait for a nonpending status
	timeout={seconds}	-> set reading timeout in seconds
	ignore_errors		-> display the data even if it is in error
	dynamic[_arrays]	-> dynamically reallocate output data variables
				   to match the number of values read
	verbose			-> verbose output
	output={spec}		-> specify output destination

	Examples:

	stats name=m:out%			! list of devices
	stats t:beamcb				! single array device
	stats/mean=var1 name=m:out%		! list of devices
	stats/min=var1/max=var2 t:beamcb	! single array device

	declare vals float[3]=2,5,11
	stats/values=vals			! perform statistics on
						! array variable

	Related commands:

	fit, read

-------------------------------------------------------------------------------

	table_device : read or set table device values

	table_device/table_type={type}[/{qualifier}] {device} [{settings}]

	This command supports reading or setting of tables contained
	in table devices.  These are most commonly waveform generator
	devices which provide ramps for power supplies.  The device to
	read or set can be specified in one of two ways.  You can either
	enter the explicit component device of interest, or the generic
	device for that card can be entered along with a desired table
	type.  This command supports an array index notation which allows
	you to specify the beginning and ending array indices
	(ex. table_device t_ha11t[1:5]).  This command supports family
	devices and list specifiers (see above).  Use of this command may
	require special privileges.  See Brian Hendricks (hendricks@fnal.gov)
	for more information.

	Examples of table_device command qualifiers:

	read			-> read table values
				   (default if no values specified)
	set			-> set table values
				   (default if values are specified)
	scaled (common)		-> make a scaled (common) reading
	raw			-> make a raw reading
	hex			-> display values in hexadecimal
	dec[imal]		-> display values in decimal (default)
	row			-> display values in a single row
	column			-> display values in a single column
	type={table_type}	-> type of table to access
				   (time, g_table, h_table, gi_table, hi_table,
				    clock, scale_factor, sf_pointer,
				    ramp_pointer, mdat_pointer, archive_data,
				    clock_int_history, diag_counters, version,
				    mdat_selection_table, offset_table,
				    offset_pointer, delay_table,
				    frequency_table, frequency_pointer,
				    phase_table, phase_pointer)
	number={table_number}	-> table number to access
	start_slot=(slot}	-> starting slot number
	num_slots={num_slots}	-> number of slots to access
	slot_type={type}	-> type of slot access
				   (whole, independent (x), dependent (y))
	x_scaling={scale_type}	-> X coordinate scaling type
				   (seconds, milliseconds, summary_secs,
				    summary_msec)
	x_values={val1,...}	-> specify X coordinate setting values
	y_values={val1,...}	-> specify Y coordinate setting values
	ft_tables={tbl1,...}	-> specify f(t) table numbers
	gi_tables={tbl1,...}	-> specify g(i) table numbers
	hi_tables={tbl1,...}	-> specify h(i) table numbers
	ft_sf_ptrs={ptr1,...}	-> specify f(t) scale factor pointer numbers
	gi_sf_ptrs={ptr1,...}	-> specify g(i) scale factor pointer numbers
	hi_sf_ptrs={ptr1,...}	-> specify h(i) scale factor pointer numbers
	ft_mdat_ptrs={ptr1,...}	-> specify f(t) MDAT pointer numbers
	gi_mdat_ptrs={ptr1,...}	-> specify g(i) MDAT pointer numbers
	hi_mdat_ptrs={ptr1,...}	-> specify h(i) MDAT pointer numbers
	file			-> read setting values from a file
				   (default file extension is ".dat")
	trigger_level={level}	-> manually trigger a level (waveform)
	add_event={event}	-> add an event to the clock table
	level={level (0-n)}	-> clock table level to add a clock event
	add_event_to_event={evt}-> add an event to the clock table on the
				   same level as a requested event
	remove_event={event}	-> remove an event from the clock table
	replace_event={event}	-> replace an event in the clock table
	new_event={event}	-> replacement event
	find_event={event}	-> find an event in the clock table
	check_for_errors	-> check a card for errors
	clear_diag_counters	-> clear diagnostic counters
	read_value={variable}	-> variable to hold reading data
	read_value_2={variable}	-> variable to hold Y reading data
	dynamic[_arrays]	-> dynamically reallocate output data variables
				   to match the number of values read
	family			-> operate on an entire family
	nodisplay		-> don't display the reading, only errors
	waitnew			-> wait for a new value to be returned (default)
	nowaitnew		-> don't wait for a new value to be returned
	pendwait		-> wait for a nonpending status
	ignore_errors		-> display the data even if it is in error
	verbose			-> display verbose output

	Examples of output specifications:

	mail:{user_name}	-> send mail to a user
	file:{file_name}	-> send output to a file

	Examples:

	table_device i_h100t[]			! read time table 0
	table_device/time i_h100[]		! read time table 0
	table_device i_h100[2]={1.0,2.0,3.0}	! set G(I) table values
	table_device/ft_tables={1,2}/hi_tables={1,1} s:466m[4]
	table_device/ft_sf_ptrs={2,2}/hi_sf_ptrs={1,1} s:466m[4]
	table_device/add_event=c2/level=3 s:465
	table_device/find_event=c2/return_level=level s:465
	table_device/remove_event=c2 s:465
	table_device/mdat_selection_table s:4530
	table_device/mdat_selection_table s:4530=m30,m31

	Related commands:

	read, set, read_field, set_field, ftd, data_source, device_list

-------------------------------------------------------------------------------

	turn : turn an ACNET device on or off

	turn[/{qualifier}] {on|off} {device}{[n]}{/qualifier...} {on|off}

	This command supports turning one or more devices either on or off.
	The specific command value can be placed before or after the device.
	This command is only valid for a device's basic control property.
	This command also supports family devices and list specifiers
	(see above).  Use of this command may require special privileges.
	See Brian Hendricks (hendricks@fnal.gov) for more information.

	Examples of turn command qualifiers:

	toggle		-> toggle the on/off status
	family		-> control an entire family
	verbose		-> generate verbose output

	Examples:

	turn i:q701 on
	turn on i:q701
	turn i:q701 off
	turn off i:q701
	turn i:q701 toggle_onoff

	Related commands:

	on, on_list, off, off_list, set, toggle, reset, reset_list, polarity,
	positive, negative, digital_control, device_list

-------------------------------------------------------------------------------

	reset : reset an ACNET device

	reset[/{qualifier}] {device}{[n]}{/qualifier...}

	This command supports reseting one or more devices.  It is only
	valid for a device's basic control property.  This command also
	supports family devices and list specifiers (see above).  
	Use of this command may require special privileges.  See Brian
	Hendricks (hendricks@fnal.gov) for more information.

	Examples of reset command qualifiers:

	family		-> reset an entire family
	verbose		-> generate verbose output

	Examples:

	reset i:q701

	Related commands:

	reset_list, on, on_list, off, off_list, set, turn, toggle, device_list

-------------------------------------------------------------------------------

	reset_list : reset a list of ACNET devices

	reset_list[/{qualifier}] {device}|device_list={list}{[n]}{/qualifier...}

	This command supports resetting one or more devices.  This command
	supports family devices and list specifiers (see above).  Use of this
	command may require special privileges.  See Brian Hendricks
	(hendricks@fnal.gov) for more information.

	Examples of reset_list command qualifiers:

	family		-> turn on an entire family
	verbose		-> generate verbose output

	Examples:

	device_list/create devs devices='z:acltst,z:aclts5,z:aclts6'/control
	reset_list device_list=devs

	Related commands:

	reset, on, on_list, off, off_list, positive, negative, polarity, set,
	turn, toggle, digital_control, device_list

-------------------------------------------------------------------------------

	toggle : toggle a status attribute of an ACNET device

	toggle {onoff|polarity|rampdc} {device}{[n]}{/qualifier...} {onoff|polarity|rampdc}

	The specific command value can be placed before or after the device.
	This command is only valid for a device's basic control property.
	This command also supports family devices and list specifiers
	(see above).  Use of this command may require special privileges.
	See Brian Hendricks (hendricks@fnal.gov) for more information.

	Examples of toggle command qualifiers:

	on_off			-> toggle on/off status
	onoff			-> toggle on/off status
	polarity		-> toggle polarity status
	ramp_dc			-> toggle ramp/DC status
	rampdc			-> toggle ramp/DC status
	enable_disable		-> toggle enable/disable status
				   (If an alarm property is selected, the
				    alarm status will be toggled.)
	enabledisable		-> toggle enable/disable status
				   (If an alarm property is selected, the
				    alarm status will be toggled.)

	Examples:

	toggle i:q701 onoff
	toggle onoff i:q701
	toggle m@outtmp enable_disable

	Related commands:

	turn, set, reset, on, off, polarity, positive, negative, device_list

-------------------------------------------------------------------------------

	enable : enable a device, a clock event, or another parameter

	enable [identifier|device{[n]}{/qualifier...}] {[constant|identifier]}

	This command can be used to enable devices belonging to certain
	device types as well as analog and digital alarms of any device
	type.  It can also be used to enable clock events and the
	notification of stale data.  This command also supports family
	devices and list specifiers (see above).  Use of this command
	may require special privileges.  See Brian Hendricks
	(hendricks@fnal.gov) for more information.

	Examples of enable command identifiers:

	stale_errors		-> enable stale data notification
	exit_on_error		-> enable errors to cause the script to exit
	dst_handling		-> enable daylight savings time corrections
				   for clink calculations
	event			-> enable a clock event
	{event string}		-> enable a clock event
	tclk			-> enable a TCLK event
	mibs			-> enable an MIBS event
	rrbs			-> enable an RRBS event
	tvbs			-> enable a TVBS event
	analog_alarm		-> enable an analog alarm
	digital_alarm		-> enable a digital alarm
	alarm			-> enable alarm indicated by property
	analog_abort		-> enable an analog alarm abort flag
	digital_abort		-> enable a digital alarm abort flag
	abort			-> enable an alarm abort flag
	analog_display		-> enable an analog alarm display flag
	digital_display		-> enable a digital alarm display flag
	alarm_display		-> enable an alarm display flag
	analog_logging		-> enable an analog alarm logging flag
	digital_logging		-> enable a digital alarm logging flag
	alarm_logging		-> enable an alarm logging flag
	analog_alarm_used	-> mark analog alarm as having been used
	digital_alarm_used	-> mark digital alarm as having been used
	alarm_used		-> mark alarm as having been used
	dbnews			-> enable database change notification
	obsolete_devices	-> allow access to obsolete devices
	family			-> enable an entire family

	Examples:

	enable stale_errors
	enable s:ssbrst
	enable m:outtmp analog_alarm
	enable event EVENT_TEV_SUDDEN_LOSS
	enable EVENT_TEV_SUDDEN_LOSS
	enable/clock=mibs 7B

	Related commands:

	disable, bypass, set, activate, deactivate, device_list

-------------------------------------------------------------------------------

	disable : disable a device, a clock event, or another parameter

	disable [identifier|device{[n]}{/qualifier...}] {[constant|identifier]}

	This command can be used to disable devices belonging to certain
	device types as well as analog and digital alarms of any device
	type.  It can also be used to disable clock events and the
	notification of stale data.  This command also supports family
	devices and list specifiers (see above).  Use of this command may
	require special privileges.  See Brian Hendricks (hendricks@fnal.gov)
	for more information.

	Examples of disable command identifiers:

	stale_errors		-> disable stale data notification
	exit_on_error		-> disable errors from causing the script
				   to exit
	dst_handling		-> disable daylight savings time corrections
				   for clink calculations
	event			-> disable a clock event
	{event string}		-> disable a clock event
	tclk			-> disable a TCLK event
	mibs			-> disable an MIBS event
	rrbs			-> disable an RRBS event
	tvbs			-> disable a TVBS event
	analog_alarm		-> disable an analog alarm
	digital_alarm		-> disable a digital alarm
	alarm			-> disable alarm indicated by device property
	analog_abort		-> disable an analog alarm abort flag
	digital_abort		-> disable a digital alarm abort flag
	abort			-> disable an alarm abort flag
	analog_display		-> disable an analog alarm display flag
	digital_display		-> disable a digital alarm display flag
	alarm_display		-> disable an alarm display flag
	analog_logging		-> disable an analog alarm logging flag
	digital_logging		-> disable a digital alarm logging flag
	alarm_logging		-> disable an alarm logging flag
	analog_alarm_used	-> mark analog alarm as never having been used
	digital_alarm_used	-> mark digital alarm as never having been used
	alarm_used		-> mark alarm as never having been used
	family			-> disable an entire family

	Examples:

	disable stale_errors
	disable s:ssbrst
	disable m:outtmp analog_alarm
	disable event EVENT_TEV_SUDDEN_LOSS
	disable EVENT_TEV_SUDDEN_LOSS
	disable/clock=mibs 7B

	Related commands:

	bypass, enable, set, activate, deactivate, device_list

-------------------------------------------------------------------------------

	bypass : bypass an alarm

	bypass {device|identifier}[[n]][/{qualifier}...]

	This command can be used to bypass analog and digital alarms.
	This command also supports family devices and list specifiers
	(see above).  Use of this command may require special privileges.
	See Brian Hendricks (hendricks@fnal.gov) for more information.

	Examples of bypass command identifiers:

	family			-> bypass an entire family
	verbose			-> display verbose output

	Examples:

	bypass m:outtmp
	bypass/verbose user_alarm_list=booster\sparks

	Related commands:

	disable, enable, set, device_list

-------------------------------------------------------------------------------

	trigger : trigger a clock event

	trigger[/clock={clock_type}] {constant|variable|symbol}

	This command will trigger a clock event.  You can also trigger beam
	synch events by specifying the type of event.  Use of this command
	may require special privileges.  See Brian Hendricks
	(hendricks@fnal.gov) for more information.

	Examples of trigger command identifiers:

	tclk		-> trigger a TCLK event (default)
	mibs		-> trigger an MIBS event
	rrbs		-> trigger an RRBS event
	tvbs		-> trigger a TVBS event

	Examples:

	trigger D9
	trigger EVENT_TEV_SUDDEN_LOSS
	trigger/clock=mibs 7B

-------------------------------------------------------------------------------

	activate : activate a device

	activate device{[n]}{/qualifier...}

	This command can be used to activate devices belonging to certain
	device types.  Use of this command may require special privileges.
	See Brian Hendricks (hendricks@fnal.gov) for more information.

	Examples:

	activate t:a1fs00

	Related commands:

	deactivate, set, enable, disable

-------------------------------------------------------------------------------

	deactivate : deactivate a device

	deactivate device{[n]}{/qualifier...}

	This command can be used to deactivate devices belonging to certain
	device types.  Use of this command may require special privileges.
	See Brian Hendricks (hendricks@fnal.gov) for more information.

	Examples:

	deactivate t:a1fs00

	Related commands:

	activate, set, disable, enable

-------------------------------------------------------------------------------

	check_status : check the basic status of devices

	check_status[/{qualifier}] {device}{[n]}[/{qualifier...}] {status_type}

	This command will check the basic status of a device or a list
	of devices to see if they match a particular status.  The status
	values that can be tested for include on, off, ready, tripped,
	remote, local, positive, negative, ramping, and DC.
	This command also supports family devices and list specifiers
	(see above).  This command sets the global symbol, $_value, to
	a value of true (1) if all devices checked match the requested
	status and a value of false (0) otherwise.

	Examples of check_status command qualifiers:

	status={status value}	 -> status to check for (on, off, etc.)
	on			 -> check for a status of on
	off			 -> check for a status of off
	ready			 -> check for a status of ready
	tripped			 -> check for a status of tripped
	remote			 -> check for a status of remote
	local			 -> check for a status of local
	positive		 -> check for a status of positive
	negative		 -> check for a status of negative
	ramp[ing]		 -> check for a status of ramping
	dc			 -> check for a status of DC
	family			 -> compare an entire family
	verbose			 -> display verbose output
	value={variable}	 -> specify a variable to hold the final
				    command status (true (matched)/false)
	suppress_errors		 -> suppress the error if a mismatch is found

	Examples:

	check_status z:acltst on		! check if on
	check_status/family t:horzfg ready	! check if family is ready

	Related commands:

	compare, read, device_list

-------------------------------------------------------------------------------

	compare : compare device readings

	compare {device}{[n]}[/{qualifier...}] [to] {source}[:{arg1}:{arg2}:{arg3}:{arg4}]

	This command will compare reading values for a device from
	two different data sources (accelerator, database, a
	save/restore file, an SDA file,	a data logger (Lumberjack), or
	a memory pool).  If no length or offset is specified, the entire
	property will be compared.  If the "device" qualifier is used,
	it can also be used to compare two different devices.  This
	command can be used for the reading, setting, basic status,
	analog alarm, and digital alarm properties.  This command also
	supports an array index notation which allows you to specify the
	beginning and ending array indices
	(e.g. compare z:acltst[1:2] to sr:last_big_save).
	This command also supports family devices and list specifiers
	(see above).  If no tolerance is specified, a tolerance of zero
	is assumed, and a raw data comparison is made.  If a nonzero
	tolerance is specified, scaled values are compared.  This command
	sets the global symbol, $_value, to a value of true (1) if the
	compare is successful and a value of false (0) otherwise.

	Type		Syntax
	----		------
	database	db
	save/restore	sr:{file number}
	SDA		sda:{file number}:{case}[:{subcase}:{usage}]
	data logger	dl:{start date}[:{node}:{accuracy in seconds}]
	memory		memory[:{pool_name}|{pool_id}]

	(Note: Arguments enclosed in square brackets are optional.)

	Examples of compare command qualifiers:

	tol(erance)={tolerance}	 -> absolute tolerance (scaled data comparison)
	%tol={percent tolerance} -> percent tolerance (scaled data comparison)
	mask={mask value}	 -> mask to apply to data before comparison
				    (raw comparison)
	scaled			 -> perform a comparison of scaled data
				    (default if tolerance is not zero)
	raw			 -> perform a comparison of raw data
				    (default if tolerance is zero)
	on_off			 -> compare on/off status only
	ready_tripped		 -> compare ready/tripped status only
	remote_local		 -> compare remote/local status only
	polarity		 -> compare polarity status only
	ramp_dc			 -> compare ramp/DC status only
	family			 -> compare an entire family
	verbose			 -> display verbose output
	device			 -> compares one device to another
	value={variable}	 -> specify a variable to hold the final
				    command status (true (matched)/false)
	suppress_errors		-> suppress the error if a mismatch is found

	Examples:

	compare z:acltst sr:1			! raw data comparison
	compare/value=status z:acltst sr:1	! raw data comparison
	compare/tol=1.5 z:acltst sr:1		! scaled data comparison
	compare/%tol=10 z:acltst sr:1		! scaled data comparison
	compare z:acltst to sda:1:"Inject Protons":1:ColliderShot
	compare z:acltst dl:"01-Jan-2000 00:00":fastest:3600
	compare z:acltst[1:2] to sr:1
	compare node=tev/crate=A1/prset to sr:last_big_save

	Related commands:

	read, search, device_list

-------------------------------------------------------------------------------

	copy : copy one device to another

	copy {src_device}{[n]}[/{qualifier...}] [to] {dest_device}{[n]}[/{qualifier...}]

	This command will copy setting values from one device to another.
	If no length or offset is specified, the entire property will be
	copied.  This command can be used for the setting, basic status,
	analog alarm, and digital alarm properties.  This command also
	supports an array index notation which allows you to specify the
	beginning and ending array indices
	(ex. copy z:acltst[1:2]/src=sr:last_big_save to z:aclts3[2:3]).
	This command also supports family devices and list specifiers
	(see above) so that one device can be copies to many devices.
	Use of this command may require special privileges.  See Brian
	Hendricks (hendricks@fnal.gov) for more information.

	Examples of copy command qualifiers:

	scaled			 -> copy scaled data (default is raw)
	family			 -> copy to an entire family
	verbose			 -> display verbose output

	Examples:

	copy z:acltst/src=sr:1 to z:aclts3	! copy entire array device
	copy z:acltst to z:aclts3		! copy entire array device
	copy z:acltst[1:2] to z:aclts3[2:3]
	copy/family t_ha11 to t:horzfg

	Related commands:

	set, fill, restore, download, device_list

-------------------------------------------------------------------------------

	copy_variable : copy a value or an array of values into a variable

	copy_variable[/{qualifier}] {variable} {copy_value} [{num_values}]

	This command copies values or arrays of values to a variable
	whether or not they are of the same type.  If the "overlay"
	option is selected, this command can do a "one to many" or
	"many to one" mapping.  This is particularly useful when
	parsing or building byte buffers.  The output variable will
	be created by this command if it doesn't already exist.

	Examples of copy_variable command qualifiers:

	overlay			-> allow a simple memory overlay which will
				   support "many to one" and "one to many"
				   mappings
	{value_type}		-> value type to use if the output variable
				   must be created
	verbose			-> display verbose output
	output			-> specify output

	Examples:

	declare val int[4]=1,2,3,4
	copyvar val2[0] val[0] 4		# simple array copy

	declare val int[4]=1,2,3,4
	copyvar/string val2[2] val[0] 2		# copy to another data type

	readfile/binary/maxbytes=128/values=rawdata/byte \
	'/usr/local/xaps/clg/utility_1.fmt'
	copyvar/overlay/string str rawdata[0:117]		#many to one
	copyvar/overlay/int maxrecords rawdata[118:121]		#many to one
	copyvar/overlay/short recordsize rawdata[122:123]	#many to one

	Pseudonyms: copy_var, copyvar

	Related commands:

	str_copy

-------------------------------------------------------------------------------

	search : search device readings for a pattern

	search {device}{[n]}[/{qualifier...}] [for] {value 1}[ {value 2} ... {value n}]

	This command will search reading values for a device for a
	specific pattern.  If no length or offset is specified, the entire
	property will be searched.  This command can be used for the
	reading, setting, basic status, analog alarm, and digital
	alarm properties.  For basic status, analog alarm, and digital
	alarm properties only raw data searches are supported.  This command
	also supports an array index notation which allows you to specify
	the beginning and ending array indices (ex. search z:acltst[1:2] for 1,2).
	This command also supports family devices and list specifiers
	(see above).  If no tolerance is specified for a scaled search,
	a tolerance of zero is assumed.  Values to be searched can be
	entered directly on the command line or can be supplied in a
	delimited text file.  This command sets the global symbol, $_value,
	to a value of true (1) if the search is successful and a value of
	false (0) otherwise.

	Examples of search command qualifiers:

	tol(erance)={tolerance}	 -> absolute tolerance (scaled data comparison)
	raw			 -> perform a raw search (default)
	auto			 -> treat search values as the default data
				    type for the device being searched (default)
	byte			 -> treat the search values as bytes
	word			 -> treat the search values as words
	long			 -> treat the search values as longwords
	scaled			 -> perform a comparison of scaled data
				    (default if tolerance is not zero)
	family			 -> search an entire family
	file			 -> read search values from a file
				    (default file extension is ".dat")
	verbose			 -> display verbose output
	value={variable}	 -> specify a variable to hold the final
				    command status (true/false)
	index={variable}	 -> specify a variable to hold the match
				    index value (-1 if no match)

	Examples:

	search i_34rc5c for 2b fe		! raw data search
	search name=i_34rc*c for 2b fe
	search/file/verbose name=i_34rc*c for search_values.dat
	search i_34rc5c[1:2] for 2b
	search/scaled z:acltst for 1.5		! scaled data search
	search/scaled/value=status z:acltst for 1.5
	search/scaled/tol=1.5 z:acltst for 1.5

	Related commands:

	read, compare

-------------------------------------------------------------------------------

	show : display database information for a device

	show[/output={spec}] {device}{[n]}[/{qualifier...}] {/parameter...}

	Multiple parameters can be specified so that multiple types of
	database information can be displayed together.  Note that a
	device index can be supplied rather than a device name.

	Examples of show command qualifiers:

	block=2			-> request alarm block starting at array index 2
	start_block=2		-> request alarm block starting at array index 2
	block=active		-> request active alarm block index
	num_blocks=4		-> request 4 alarm blocks
	source=dp		-> display data from the accelerator (default)
	source=db		-> display data from the database
	source=sr:1		-> display data from save/restore file 1
	source=sda:1:"Inject Protons":1:ColliderShot	-> display data from SDA
							   file 1, case Inject Protons,
							   subcase (set) 1,
							   usage ColliderShot
	source=dl:"01-JAN-2000 01:00"	-> display data from a Lumberjack at
					   January 1, 2000 at 0100
	source=memory		-> display data from a memory pool
	obsolete		-> support handling of obsolete devices
	verbose			-> display verbose output
	noheader		-> suppress device name header
	nodisplay		-> don't display the data, only errors
	status={var|symbol}	-> returns the retrieval status in a variable
	output={spec}		-> specify output destination

	Examples of parameters are:

	/name		    -> display device's name
	/device_index	    -> display device index
	/full_name	    -> display device's full name
	/fermi_name	    -> display FermiName(s) for a device
	/fermi_index	    -> display FermiName atom indices for a device
	/text		    -> display device's descriptive text
	/full_text	    -> display device's full descriptive text
	/node		    -> display device's source node
	/property	    -> display individual property information
	/property_info	    -> display individual property information
	/ssdn		    -> display individual property SSDN
	/sizes		    -> display individual property sizes
	/location	    -> display device's location information
	/alarm_block	    -> display alarm block information from the front end
	/db_alarm_block	    -> display alarm block information from the database
	/alarm_flags	    -> display alarm display and logging enabled flags
	/alarm_handling	    -> display alarm handling information
	/dbset		    -> display saved database setting values
	/dbset_raw	    -> display raw saved database setting values
	/audit		    -> display device's audit history
	/created	    -> display device creator and creation date
	/last_modified	    -> display last device modifier and modify date
	/bitnames	    -> display bit descriptions for the status property
	/extended_text	    -> display bit descriptions for the status property
	/bit_status	    -> display current bit status text
	/status_text	    -> display current bit status text
	/save		    -> display save/restore information
	/save_info	    -> display save/restore information
	/save_list	    -> display save/restore list information
	/user_save_lists    -> displays all user save lists which contain
			       this device
	/device_type	    -> display device's type (database type)
	/live_device_type   -> display device's type (calculated)
	/analog_text	    -> display analog alarm text
	/digital_text	    -> display digital alarm text
	/alarm_text	    -> display analog or digital alarm text depending
			       on the selected property
	/scaling	    -> display scaling information
	/scaling_info	    -> display scaling information
	/digital_control    -> display digital control information
	/units		    -> units text
	/primary_units	    -> primary units text
	/status_attr	    -> display basic status attributes
	/status_attributes  -> display basic status attributes
	/control_attr	    -> display basic control attributes
	/control_attributes -> display basic control attributes
	/virtual_machine    -> display virtual machine information
	/setting_protection -> display setting protection information
	/controlled_set	    -> display controlled setting status
	/emc		    -> display EMC information
	/data_type	    -> display property data type information
	/sibling	    -> display sibling information
	/family		    -> display family information (family devices only)
	/state_text	    -> display state text (state devices only)
	/out_of_service	    -> display out of service (broken) information
	/oos(broken)	    -> display out of service (broken) information
	/plot_class	    -> display FTP and snapshot plot class information
	/alarm_list	    -> display alarm list information
	/alarm_lists	    -> display alarm lists containing the device
	/properties	    -> list the existing properties for a device
	/download	    -> display device download information
	/download_props	    -> display device download properties
	/families	    -> list the families that a device is a member of
	/composites	    -> list the composite devices that a device is a
			       member of
	/ssdr		    -> display SSDR (SubSystem Device Record) data
	/extrema	    -> displays the minimum and maximum scaled values
			       for a property
	/controlling_device -> displays the device which controls the
			       requested device
	/controlled_devices -> displays the list of devices which the
			       requested device controls
	/help		    -> displays the help for the device
	/url		    -> displays the help URL for a device
	/expr[ession]	    -> displays device reading expression
			       (for calculational devices only)
	/logger_lists	    -> displays all data logger list entries for
			       the device
	/param_pages	    -> displays all parameter pages containing the
			       device

	Examples of output specifications:

	mail:{user_name}	 -> send mail to a user
	file:{file_name}	 -> send output to a file

	Examples:

	show m:outtmp/name/analog_text
	show t:ha11/name/digital_text/status_attr/control_attr/property_info

	Related commands:

	read, delete_cache, list, device_list

-------------------------------------------------------------------------------

	list : list device parameters

	list {device{[n]}{/qualifier...}|tag=value|file} [/option={value}]
	{format_string} [/output={spec}]

	This command produces a formatted listing of parameters for one
	or more devices.  Note that a device index can be supplied rather
	than a device name.

	Examples of the tag=value pairs:

	file={file}		 -> list all devices from an ASCII file
	dbdi={table}		 -> list all devices specified by the column
				    named "di" (int) in a DB table
	dbname={table}		 -> list all devices specified by the column
				    named "name" (char(8)) in a DB table
	devices={dev1,dev2,...}	 -> list devices from an explicit delimited
				    list of names
	node=tev		 -> list all devices from the Tevatron front end
	name=t:ha%		 -> list all devices whose names start with
				    "T:HA"
	family=t:ha11z		 -> list all devices in the family T:HA11Z
	text=ha%		 -> list all devices whose descriptive text
				    starts with "HA"
	save_list=1		 -> list all devices attached to save/restore
				    list number 1
	sul=booster\400_mev\vert -> list all devices in a user save list
	save_code=1		 -> list all devices having a save/restore
				    save code of 1
	type=377		 -> list all C377 devices
	type='CAMAC C377'	 -> list all C377 devices
	class=dio_camac_device	 -> list all CAMAC devices
	transform=2		 -> list all devices using common transform 2
	crate=a1,node=tev	 -> list all devices from Tev crate A1
	slot=1,crate=a1,node=tev -> list all devices from Tev crate A1, slot 1
	madc=1,node=tev		 -> list all devices from Tev MADC #1
	driver=0xD		 -> list all devices with driver code 0D
	vm=v:falma1		 -> list all devices belonging to virtual
				    machine V:FALMA1
	units="sec "		 -> list all devices having units text of "sec "
	alarm_list=FixTgt	 -> list all devices from alarm list "FixTgt"
	aul=booster\sparks	 -> list all devices from a user alarm list
	ah=Normal		 -> list all devices having a given alarm
				    handler
	cd={device}		 -> list all devices controlled by a given
				    device
	expr[ession]=%t:rn%	 -> list all devices containing a given string
				    in its reading expression
	expr_device=t:rn000a	 -> list all devices containing a given device
				    in its reading expression
	download_list=baker	 -> list all download devices for node BAKER
	save_file=821		 -> list all devices saved in save file 821
	sda_set=1587:2:1	 -> list all devices saved in SDA file 1587,
				    case 2, set 1
	console_class={class}	 -> list all devices which are settable
				    by a given console class

	Examples of options are:

	/title=yes		 -> display a default title (default)
	/title=no		 -> don't display a title
	/notitle		 -> don't display a title
	/title="My Title"	 -> display a specific title
	/headings=yes		 -> display column headings (default)
	/headings=no		 -> don't display column headings
	/noheadings		 -> don't display column headings
	/summary		 -> display the number of devices listed
	/comment="This is a comment."
	/skipbad		 -> skips invalid entries in a device file
	/filter=analog_alarm	 -> only display devices in alarm (analog)
	/filter=digital_alarm	 -> only display devices in alarm (digital)
	/filter=broken		 -> only display devices marked as out of service
	/filter=analog_bypassed	 -> only display devices with analog alarm bypassed
	/filter=digital_bypassed -> only display devices with digital alarm bypassed
	/filter=read_array	 -> only display devices with an array reading property
	/filter=set_array	 -> only display devices with an array setting property
	/filter=status_array	 -> only display devices with an array status property
	/filter=read_size_mismatch -> only display devices with a reading size mismatch
	/filter=set_size_mismatch  -> only display devices with a setting size mismatch
	/filter=has_reading	 -> only display devices having a reading property
	/filter=has_setting	 -> only display devices having a setting property
	/filter=has_status	 -> only display devices having a status property
	/filter=has_control	 -> only display devices having a control property
	/filter=has_analog_alarm -> only display devices having an analog alarm property
	/filter=has_digital_alarm -> only display devices having a digital alarm property
	/source=dp		 -> display data from the accelerator (default)
	/source=db		 -> display data from the database
	/source=sr:1		 -> display data from save/restore file 1
	/source=sda:1:"Inject Protons":1:ColliderShot	-> display data from SDA
							   file 1, case Inject Protons,
							   subcase (set) 1,
							   usage ColliderShot
	/source=dl:"01-JAN-2000 01:00"	-> display data from a Lumberjack at
					   January 1, 2000 at 0100
	/source=memory		 -> display data from a memory pool
	/output={spec}		 -> specify output destination
	/num_strings={variable}	 -> saves the number of strings in a variable
	/strings={array}	 -> saves the output strings in a variable
	/dynamic[_arrays]	 -> dynamically reallocate output data string
				    to match the number of output strings

	Examples of format specifiers:

	%nm		 -> display device name
	%di		 -> display device index
	%tx		 -> display device descriptive text
	%fn		 -> display device FermiName
	%fi		 -> display device FermiName atom index
	%nd[_p]		 -> display device source node
	%tn[_p]		 -> display device source trunk and node
	%type_p		 -> display device type
	%type_long_p	 -> display device type (long description)
	%class_p	 -> display device class
	%rd		 -> display current device reading
	%rd_units	 -> display reading units
	%set		 -> display current device setting
	%set_units	 -> display device setting units
	%sts		 -> display current device basic status
	%raw_p		 -> display a raw reading value
	%primary_p	  -> display a reading value in primary units
	%aa		 -> display analog alarm
	%aa_min		 -> display analog alarm minimum
	%aa_max		 -> display analog alarm maximum
	%aa_nom		 -> display analog alarm nominal
	%aa_tol		 -> display analog alarm tolerance
	%aa_ll		 -> display analog alarm limit length
	%aa_lt		 -> display analog alarm limit type
	%aa_ldt		 -> display analog alarm limit data type
	%aa_status	 -> display analog alarm status
	%aa_hl		 -> display analog alarm high/low status
	%aa_ena		 -> display analog alarm enable status
	%aa_abort	 -> display analog alarm abort status
	%aa_abtena	 -> display analog alarm abort enable status
	%aa_pri		 -> display analog alarm priority
	%aa_text	 -> display analog alarm text
	%aa_display	 -> display analog alarm display enable status
	%aa_logging	 -> display analog alarm logging enable status
	%aa_tries_needed -> display analog alarm tries needed
	%aa_tries_now	 -> display analog alarm tries now
	%aa_evt1	 -> display analog alarm event 1
	%aa_evt2	 -> display analog alarm event 2
	%aa_ftd		 -> display analog alarm FTD
	%aa_pm		 -> display analog alarm post method
	%aa_data	 -> display analog alarm special data
	%aa_flags	 -> display analog alarm flags word
	%da		 -> display digital alarm
	%da_nom		 -> display digital alarm nominal
	%da_mask	 -> display digital alarm mask
	%da_ll		 -> display digital alarm limit length
	%da_status	 -> display digital alarm status
	%da_status	 -> display digital alarm status
	%da_ena		 -> display digital alarm enable status
	%da_abort	 -> display digital alarm abort status
	%da_abtena	 -> display digital alarm abort enable status
	%da_display	 -> display digital alarm display enable status
	%da_logging	 -> display digital alarm logging enable status
	%da_tries_needed -> display digital alarm tries needed
	%da_tries_now	 -> display digital alarm tries now
	%da_evt1	 -> display digital alarm event 1
	%da_evt2	 -> display digital alarm event 2
	%da_ftd		 -> display digital alarm FTD
	%da_pm		 -> display digital alarm post method
	%da_data	 -> display digital alarm special data
	%da_flags	 -> display digital alarm flags word
	%dbset_p	 -> display saved database setting values
	%dbset_raw_p	 -> display raw saved database setting values
	%units_p	 -> display common units text
	%pt_p		 -> display primary transform (text)
	%pt_index_p	 -> display primary transform (number)
	%ct_p		 -> display common transform (text)
	%ct_index_p	 -> display common transform (number)
	%const_p(_n)	 -> display scaling constants (If "n" is specified,
			    only the corresponding constant will be displayed.)
	%dl_p		 -> display scaled display length
	%df_p		 -> display scaled display format
	%ps		 -> display previous sibling
	%ns		 -> display next sibling
	%sl		 -> display save/restore save list
	%sln		 -> display save/restore save list number
	%sc		 -> display save/restore save code
	%dc		 -> display save/restore display code
	%sp		 -> display save properties
	%sm		 -> display save property mask
	%pm		 -> display device setting protection mask
	%vm		 -> display device virtual machine information
	%oos		 -> display device out of service (broken) status
	%ssdn_p(_n)	 -> display device SSDN (If "n" is specified, only
			    the corresponding word will be displayed.)
	%ds_p		 -> display device default size
	%as_p		 -> display device atomic size
	%ms_p		 -> display device maximum size
	%ss_p		 -> display device scaling size
	%ne_p		 -> display device number of elements
	%emc_p		 -> display device EMC
	%cr_p		 -> display device crate
	%slt_p		 -> display device slot
	%ch_p		 -> display device MADC channel
	%madc_ch_p	 -> display device MADC channel
	%madc_num_p	 -> display device MADC number
	%ftd_p		 -> display device default FTD
	%fa_date	 -> display first audit date
	%fa_author	 -> display first audit author
	%la_date	 -> display last audit date
	%la_author	 -> display last audit author
	%state_value	 -> display state value text (sv)
	%fermi_name	 -> display FermiName for device
	%ftp_class	 -> display FTP (Fast Time Plot) class (text)
	%ftp_class_index -> display FTP (Fast Time Plot) class (number)
	%snp_class	 -> display SNP (Snapshot) class (text)
	%snp_class_index -> display SNP (Snapshot) class (number)
	%cs		 -> display controlled setting status
	%is_cntrl_set	 -> display controlled setting status
	%is_motor	 -> display motor controller status
	%data_type_id_p  -> display device data type ID
	%al		 -> display alarm list
	%aln		 -> display alarm list number
	%acl		 -> display alarm control list
	%ah_p		 -> display alarm handler
	%ahn_p		 -> display alarm handler number
	%asid_p		 -> display alarm sound ID
	%aspid_p	 -> display alarm speech ID
	%cd		 -> display controlling device
	%expr		 -> display expression used to calculate
			    the device's reading value
	%cnv_device_driver_p	-> display device driver value
	(Suffixes of "_p" mean that a property string should be inserted in
	 place of the "p".  The property strings for this are "rd", "set",
	 "sts", "ctl", "aa", and "da".)
	(for more help see the help for the CLIB routine 'device_listing_c')

	Examples of output specifications:

	mail:{user_name}	-> send mail to a user
	file:{file_name}	-> send output to a file

	Examples:

	list m:outtmp "%nm %tx %set %rd %rd_units %sts"
	list transform=38 "%nm"
	list data_file.txt "%nm %la_date %la_author"
	list 27235 "%nm"		! get device name from device index

	Related commands:

	read, show, alarm_limit, nominal_mask, device_list

-------------------------------------------------------------------------------

	alarm_limit : read or set analog alarm limits

	alarm_limit[/{qualifier}] {device|identifier}[[n]][=][{minimum},{maximum}]

	This command supports reading or setting of analog alarm limits.
	One or more blocks of multiple alarm block devices can be displayed
	or set.  This command supports an array index notation which allows
	you to specify the beginning and ending alarm blocks
	(ex. alarm_limit t:a1spwe[3:5]).  This command also supports family
	devices and list specifiers (see above).  Use of this command may
	require special privileges.  See Brian Hendricks (hendricks@fnal.gov)
	for more information.

	Examples of alarm_limit command qualifiers:

	read			-> read alarm limits
				   (default if no limits specified)
	set			-> set alarm limits
				   (default if one or both limits are specified)
	minmax			-> treat limits as minimum/maximum
				   (default for setting)
	nomtol			-> treat limits as nominal/tolerance
	min[imum]={minimum}	-> specifies minimum value for setting mode
	max[imum]={maximum}	-> specifies maximum value for setting mode
	nominal={nominal}	-> specifies nominal value for setting mode
	tolerance={tolerance}	-> specifie