 
		CCL  -  Console Command Language
		           Version V8.0
 
     CCL V8.0 may either be used as a Catchall task for MCR, or it may
 be installed and used as an Alternate CLI.  If it is installed as the
 Catchall task (...CA.), and MCR does not accept the command line input
 an an internal MCR command or as an external MCR command, the entire MCR
 command buffer is passed on to a catchall task ...CA. 
     CCL then scans the command to see if it corresponds to any internal
 CCL commands.  If the command is found it is interpreted and sent to MCR.  
 If the command is not found, an attempt is made to decode the command using 
 either a command definition file on the user's LOGIN UIC (SY:USERCCL.CCL)
 or a system command definition file (LB1:[1,5]SYSCCL.CCL).

     Further HELP using CCL may be obtained using the following keywords.

	CLI			Installing and Using CCL as an Alternate CLI
	COMMANDS
	COMMANDS BUILT_IN	Internal CCL commands you may use.
	COMMAND FILE		Creating a USERCCL.CCL command file.
	COMMAND FILE SYNTAX	Required structure for the command file.
	COMMAND FILE EXAMPLE	Detailed examples of CCL commands.
	INTRODUCTION		Introduction to how CCL works.
	IDENT			Getting current version # for CCL

2	INTRODUCTION

          The normal user interface to an RSX11M operating  system  is
     via  MCR  (Monitor  Console  Routine).   If terminal input is not
     specifically requested by a task, all data, or commands typed  in
     at  a  user's terminal are sent by the terminal driver to MCR for
     decoding.  The MCR task (and its child ...SYS) decode  user  com-
     mands(ACT,  ABORT, RUN, DEV, etc.).  Tasks installed with special
     names of the form ...XYZ are treated as a external  MCR  command.
     Hence if a user types 
      
     			XYZ commandline
      
     the 'commandline' in its entirity(or at least up to 79 characters
     is  sent  as  input to the task ...xyz.  this is the conventional
     way of supplying most system commands and controling  the  opera-
     tion  of  the  RSX11M  utility programs.  The limitations of this
     method are that each task must be installed to be treated  as  an
     external  MCR  command, and each extra installed task, uses valu-
     able pool space.  Moreover, because installed tasks use a  criti-
     cal  system  resource(pool),  only privleged users are allowed to
     install and remove tasks from the system.   The  normal  user  is
     restricted  to  starting tasks via the RUN command or using those
     tasks already installed.
~

          To alleviate this problem a user tailorable Console  Command
     Language  (CCL)  has  been  implemented which allows each user to
     have a private task control  language  which  will  pass  command
     lines  to tasks which are not installed in the system as external
     MCR commands.  When a user types in a command line, MCR is  given
     first  crack  at decoding it.  If MCR does not recognize the com-
     mand(first 3 letters) as either an internal( like  SET  /UIC)  or
     external  command,  then the command line in its entirity is sent
     to CCL which is installed as ...CA., the the catchall task.   CCL
     in  turn  checks  to  see  if it can find the command(the command
     stops at the first space, comma, =, <, or carriage return encoun-
     tered).   First it looks in its internal command tables to see if
     the command matches.  If the command does not match it then scans
     a  user file USERCCL.CCL to see if the command is present.  If it
     isn't,it checks in file LB1:[1,5]SYSCCL.CCL to see if the command
     is a system CCL command.  If the command is not found anywhere, a
     warning message is printed.

          Each user may have an  individual  CCL  (USERCCL.CCL)  file.
     Instructions on how to structure a CCL file may be found by  typ-
     ing HELP CCL COMMAND SYNTAX and some worked examples may  be seen
     by typing HELP CCL COMMAND EXAMPLE.
2	CLI

	CCL may be installed as an Alternate CLI to MCR.  In this case
     a terminal which sets its CLI to be CCL (SET /CLI=TI:CCL) will have
     all its commands sent to CCL for decoding prior to CCL decoding the
     commands and sending them back to MCR.  The command lookup sequence
     is slightly different if CCL is used as an Alternate CLI.  The order
     is:
			1) Check internal tables
			2) Check SY:[UIC]USERCLI.CCL
			3) Check LB1:[1,5]SYSCLI.CCL

     If the command is not found it is sent to MCR unmodified.  A user may
     return to MCR at any time by typing SET /MCR=TI:

         Further HELP may be obtained with

		HELP CCL CLI INSTALL
3	INSTALL

	 If CCL is to be used as an alternate CLI it should be installed
     twice as in the following example
	
		INS $CCL/TASK=...CA./PRI=60.
		INS $CCL/CLI=YES/TASK=...CCL/PRI=70.
		CLI /INIT=CCL/CPR="<15><12>/CCL>/"/DPR="<15><12>/>/"
		CLI /ENABLE=CCL

        The same task image will either work as an alternate CLI or as the
    Catchall task ...CA.  CCL can not be used as the second Catchall task
    ...CA2 or any other name.  It uses its installed name to decide whether
    or not it is a CLI on a system supporting Multiple CLI's.

2	COMMANDS

          A wealth of CCL commands exist to  simplify  the  amount  of
     type  in  a  user  has to do, and to allow the user access to the
     wide variety of RSX utility programs which  are  not  perminently
     installed in the system.

          In addition a number of commonly  used  commands  are  built
     into  CCL.   The  commands  SORT, DELETE, DIRECTORY, LIST, PURGE,
     SPOOL, TRUNCATE, FREE, UIC, POOL, ATS, DLG, SHW, SHQ and HEY  are
     internally  decoded by CCL .  Many of these commands are executed
     as PIP file commands and their syntax is

     		COMMAND  [filespec] [,filespec] ...
      
     The commands  DIR and SORT do not require  a  filespecifier.  Some
     commands will prompt for input(COPY, PURGE, DELETE, LIST, TRUNCATE,
     and SPOOL) if the file specifier is omitted. For HELP  with  the 
     BUILT_IN commands, type HELP CCL COMMANDS BUILT_IN. For information 
     on the system CCL commands available to the user, type 
     HELP CCL COMMANDS SYSTEM.
3	BUILT_IN

     A large number of internal commands also exist to decrease the
 ammount of type in necessary at one's terminal.  These commands
 are(only the first 3 letters are required)
 
  ATS [TTn:]		Display active tasks [for specified terminal].
  BELL			Rings terminal bell.
  DELETE filspec	Delete files.
  DLG			Display logged in terminals.
  DLY NNNU		Delay NNN U units of time
  DIRECTORY [filspec]	Provide a directory listing.
  FREE  [DDn:]		Provide a free block display of the disk
  HEY tsknam		Connect to a task and notify user on exit.
  IDENT			Display the current version of CCL
  LIST [filspec]	List a file at terminal.(uses ...LIS if installed).
  NOSCROLL		Sets VT100 to fast scroll.
  PAGE			Erases screen of VT100 or TEK 4014 terminal.
  POOL			Display free pool.
  PURGE [filspec]	Purge files.
  SCROLL		Sets VT100 to slow scroll.
~
  SHQ			Show print queue(QUE /LI)
  SORT [filspec]	Provide a rapid, sorted directory listing
  SYS			Display system UIC.
  TRUNCATE [filspec]	Truncate files
  TYPE filespec		Lists a file at terminal (uses PIP)
  UIC 			Display terminal's UIC(SET /UIC).
  UIC grm mem		SET /UIC = [grm,mem]
  UIC [grp,mem]		 "    "      "   "



3	SYSTEM      

          Note:	Command lines for utilities started by CCL are
     		limited to 40-50 characters.
      
     ACCLOG			RUN $ACCLOG
     ACNT			RUN $ACNT
     BASIC			RUN $BASIC/INC=4092/TASK=...BAS
     BUF [nn]			SET /BUF = TI:[nn]
     BCK			RUN $RMSBCK
     CHKSUM filespec		PAT NL:=filespec/CS,filespec
     CDA dev:=MM0:/SW		CDA dev:=MM0:/SW,LB:[1,54]RSX11M.STB/STB
     CMP command line		Identical to CMP syntax
     CVL command line		Identical to CVL syntax
     DATEL			RUN $DATEL
     DIOP			RUN $DIOP
     DMP command line		Identical to DMP syntax
     DSP			RUN $RMSDSP
     FLX command line		Identical to FLX syntax
     FTB commandline		Identical to FTB syntax
     LBR commandline		Identical to LBR syntax
     PAT commandline		Identical to PAT syntax
     RNO commandline		Identical to RNO format.
~
     RST			RUN $RMSRST
     SHOW			#LB:[1,2]SHOW.PRC
     SLP @commandfile.slp	Identical to SLP syntax
     SUB GRP/MEM/PSWRD CMD	Identical to SUBMIT syntax
     VFY commandline		Identical to VFY syntax
     VMR			Identical to VMR syntax
     ZAP			Identical to ZAP syntax

     PRIVLEGED SYSTEM COMMANDS

     ACS DEV:/BLKS=N		Identical to MCR
     ERF			Identical to MCR
     ERRORS			@LB:[1,6]ERROR
     INCBKP			@[1,7]INCBKP
     LOA(D) DEV:		LOA DEV:/PAR=DRVPAR
     PSE			Identical to MCR
     SHUTUP			@LB:[1,2]SHUTDOWN
     SYE			Identical to MCR
     UFD dev:[UIC]		Identical to MCR
     UNL(OAD) DEV:		Identical to MCR
3	FILE

          When ...CA.  is activated from MCR...  the  programs  obtain
     the  command  line from MCR and divides it into units.  The first
     unit is the KEYWORD which is used to select the command from  the
     definition(.CCL)  files.  The other units become parameters 1 thu
     9 and A thru C.  The alphabetic characters represent major sub-
     sections of the command line.  A includes the entire command line
     minus the keyword.  B includes all input up to the first space or
     carriage return minus the keyword and any leading  switches  (see
     parameter 0).  C includes everything from the first space to  the 
     end of the command line (minus the space delimeter).  Parameter 0
     includes any leading switches appended to the keyword, continuing
     to the first space (e.g. BRU/REW, parameter 0 = /REW). Parameters
     1-9 are then assigned, in order, to each unit in the command line
     (minus delimeters) that are separated by spaces, commas, '=' or
     '<. symbols.  Given this command breakdown: the MCR line includes
     the KEYWORD and parameter A; parameter A includes parameters 0,B,
     and C; and parameters B and C include parameters 1-9. The keywords 
     are matched up to 8 characters.  CCL has the option top prompt for
     missing parameters and will exit if the required input is termin-
     ated with ^Z.

          A user command definition file(SY:USERCCL.CCL)  is  searched
     for.   If  present  it is opened and scanned for a keyword match.
     If  it  is  not  present,  the  system  command  definition  file
     (LB1:[1,5]SYSCCL.CCL) is opened and scanned.  If the user file is
     scanned and the command is not found, then it is closed  and  the
     system  file  is  scanned  in  turn.  If the command is not found
     after the scan of the system file completes and  the  keyword  is
     terminated by a '?' character, the files are rescanned for a com-
     mand '?' which is called with its first parameter as the origioal
     keyword(less  the  '?').  This was added as an additional form of
     help command.  The system CCL command  file  interprets  the  '?'
     command as 'HELP'.  Hence, PIP?  is the same as HELP PIP.
~

          The command definition files have three main types of lines,
      
     	1)  beginning '$' - keyword lines (identification line)
     	2)  beginning '?' - keyword lines (input querry line)
     	3)  beginning '*','+', or '-' lines (action lines).
      

          The command file consists of a keyword  identification  line
     followed  by  optional  input  querry lines and finally by one or
     more action lines.  The match procedure consists of comparing the
     keyword  from  the  command  line with the keyword in the command
     file.  If the minnumum length of match is satisfied and the char-
     acters up to the end of the command line keyword match characters
     in the keyword line, the match is successful.  Otherwise  failure
     is  signaled  and another '$' keyword line is searched for.  When
     no more keyword lines are found in the file, the file  is  closed
     and the search has failed in finding that command line.

4	SYNTAX

          The keyword line is as follows,
      
     $<m1><m2><mp><ap>KEYWORD
      
        	First line of a command set.  There may be many
     		keyword lines for the same action line.
      
     	<m1>	Minimum number of characters to match.
     	<m2>	Maximum number of characters to match.
        	(If 0, no check for user KEYWORD > file KEYWORD is made).
     	<mp>	Minimum number of parameters required.
     		If this number of parameters is not present then
     		parameters will be prompted for.
     	<ap>	Maximum number of parameters to question for if 
     		less than <mp> parameters are input.  In the case
      		where prompting this number is the highest prompt
     		 to be requested.
      
             KEYWORD is the command keyword.
~      
      
     	The keyword consists of a character string to be matched
     	identically by the CCL processor.  If the 'm2' parameter
     	is 0, no checking for maximum keyword length will be
     	performed.  For example, given two keyword lines $3400DUMP
     	and $3000DUMP, a user command of 'DUMPIT', will fail to
     	match the first keyword line (DUMPIT exceeds maximum of
     	4 characters), but will match the second keyword line
     	(maximum keyword length checking disabled).  Keywords
     	may extend beyond the 9 character limit imposed by the
     	single digit parameters m1 and m2 by adding 60(octal) to
     	the desired number and entering the corresponding ASCII
     	character, e.g. to specify m2 = 11 (dec.) use ASCII character
	';'.  Terminators for the keyword typed by the user are
     	space, '/', and carriage return.
      
     ?<n>QUESTION-TEXT
      
     	Where <n> is the parameter number (they should be in order)
     	(1-9, A-C). If the correct number of parameters are
     	supplied no questions are asked, otherwise questions are
     	asked and the associated parameters are filled in.
     	If parameters are skipped then they will only have values
     	if they were given on the original command line.
      
      
     < >KEYWORD command-line<+>   where < > is one of '-', '+', or '*'
			          where <+> is null or '+'.
~

          Action lines come in two varieties.   '-'  lines  are  lines
     which  instruct  the  program to wait for a given task.  The task
     name is an absolute name and does not take on a  terminal  quali-
     fied  name (V3.2 does  not have executive task dispatching).  CCL
     will issue a connect directive to the specified task and  if  the
     task  is  found and is active, it will stop itself until the task
     exits.  The format for the wait line is
      
     		-<6-char-taskname>
      

          The '*' and '+' command lines differ only in  that  the  '+'
     line  signals  that  further command lines follow in the file.  A
     '*' signals that the command is the last or  only  command  line.
     The  text in the action line is copied except that any parameters
     present are substituted into the text  line.   The  action  lines
     consist  of  valid  MCR  commands  which must not involve further
     calls to CCL.  Any action line which is too long to be placed  on
     a single line may be continued to the next line by  placing a '+'
     as the last character in the action line.  Note: the '+' must not
     be in the middle of a parameter substitution string, rather it must
     stand alone as if it were to be placed firectly into the  command
     line.  However, the total output line length to MCR is limited to
     79 characters.
~

        Three special fields in the action line suspend direct transfer
     of characters from the action line to the new command line:
     1) Parameter substitution fields, 2) Parameter test and substitute
     fields, and 3) Special parameter substitution fields. A '%' denotes
     a substitution argument, and is normally associated with a parameter
     number  <pn> or a special symbol.   Parameters are  defined  by the
     presence  of delimiters  in  the original  MCR  command  line or by 
     response to an input query line.  The comma seperating the group and
     member numbers in a UIC field ([g,m]) is treated as a special case,
     and not considered a delimiter, thereby placing the entire UIC within
     one parameter.

        Parameter substitution fields allow insertion of the parameters
     0-9, A-C into the new command line by using the format:
     
          	%<pn><option1><option 2><option 3>%
     where
     	<pn>		is the parameter to be substituted(1-9,A-C)
     	<option 1>	is one of null, '=', or ','
     	<option 2>	is one of null, <test char>text string
	<option 3>	is one of null or \text-string
     or
     	%<spec-char>	is one of '$','%','D','G','M','P','Q'
				        'T',or 'U'.
~

          The '%' denote a parameter substitution argument.  The  <pn>
     is  the  number  of the associated parameter to be substituted or
     one of the special parameters.   Each  terminal  input  parameter
     must  be seperated by a delimiter.  Valid delimiters are:  space,
     comma(','), '=','<', 

          The first group of optional elements denote a  character  to
     be  inserted  before  the parameter if the parameter is not null.
     Only ',' or '=' may appear in this  position (ie be  inserted  in
     front  of the parameter).  The second group denote elements to be
     appended if their initial character is not present in  the  input
     parameter  string.   Typically  these are only those which denote
     file extensions and version numbers.  If the <test char>  is  not
     found  in  the  body of the parameter then that character and the
     text string following it (up to '%' or '\') are  appended  to the
     parameter.  The final option denotes a text string to be inserted
     directly into the command line if parameter <pn> is null (the '\'
     character is not included).
~
     
          The parameter test and substitute field allows  the  user to
     control insertion of text strings into the new command line based
     on the status of a parameter (null or not null). It has the form:

		%<pn>?<string1><\stromg2>%

     where:

        <pn>		is the parameter to test (0-9, A-C)
	?		Key character to indicate a test field.
	<string1>	is one of null or ASCII string.
	<\string2>	is one of null or ASCII string preceeded by
			backslash.  If null and %Q is found, CCL will
			exit without sending a command to MCR.

           Encountering the '%<pn>?' field in the action line causes CCL
      to determine if parameter <pn> is null. If <pn> is null, the ASCII
      string preceeded by '\' and ending with % will be inserted directly
      into the command line (minus delimiters).  If <pn> is not null, any
      string immediately following the '?' up to a '\' or '%' will be 
      inserted into the new command line.  If a required input field is
      defaulted and the default substitution string is NULL (ie \%0 and 
      the %Q  (quit) special parameter has been encountered, CCL will 
      exit without sending a command to MCR. 
~

          The special parameters are as follows,
      
     	
     	%$	As the last element in the command line signifies
     		that CCL should SPAWN the command to MCR and exit(ESCAPE)
     		rather than to stop itsef and wait for exit status.
	%%	Enables the second % to be accepted as a literal.
	%D	Debug switch.  When encountered, the expanded command
		line is printed at the issuing terminal with a debug
		message.
     	%G	The group number of the UIC.
     	%M	The member number of the UIC.
	%P	Print.  The action line will be printed on TI:
		Must be last element in line.
	%Q	Exit without sending a command to MCR if required parameter
		has a null default parameter and null input parameter.
	%R	Ring the terminal bell when CCL exits.
     	%T	The user's terminal ID(Tnn or Vnn where 'nn' is the
     		terminal number and 'Tnn' or 'Vnn' are for real terminals
     		and virtual terminals respectively.
     	%U	The user's UIC including '[,]'.
~
      
     examples:
     	%U	->	[12,10]
     	%G	->	12
     	%M	->	10
     	%T	->	T14 if TT14:, V1 if VT01:
     			useful for creating multi-terminal tasks(ie BAST2)
     			using INS/TASK=nnn%T.

      
          After a CCL command is issued CCL  stops  itself  until  the
     command  is  complete.   When  the task completes it returns exit
     status back to CCL, which in turn passes exit status back to  the
     task which invoked it(such as ...AT.).  If the user does not wish
     CCL to stay arround for the command to finish, a %$%  may  termi-
     nate  the  command  in  the  command  skeleton  in  the user's(or
     system's) CCL file.  This has changed from the  previous  release
     because  the  way in which MCR syncronizes with external tasks is
     now radically different.  In short, if %$% terminates a CCL  com-
     mand,  CCL  will  spawn  the command to MCR and immediately exit.
     Otherwise, it will stay in core until the command is processed.
4	EXAMPLES

 Sample CCL command file
      
     	$1111M
     	$2811ASSEMBLE
     	?1Filename
     	*MAC %1%=LB:[1,1]EXEMC/Ml,[11,10]RSXMC/PA:1,LB:%U%1%
     	$1411TYPE
     	$2411LIST
     	?1File
     	*PIP TI:=%1.MAC%%2,.MAC%%3,.MAC%
     	$2822COMPARE
     	?1Files
     	?2Output
     	*CMP %2.SLP%/SL=%1;-1%,%1;0%
     	$5511BUILD
     	?1FILE
     	+F4P %1.OBJ;1%=1%
     	+TKB %1.TSK;1/CP/FP%=%1%,LB:[1,1]F4POTS/LB
     	+PIP %1.OBJ;1%/DE
     	+RUN %1%
     	-%1%
     	*PIP %1.TSK;1%/DE
~
          The commands " M file " and "ASSEMBLE FILE"  have  the  same
     effect,  they  create  an object file from the source in [12,10].
     The command ASSEMBLE given without any parameters would result in
     the  prompt  "Filename?"  since the specification for the command
     requires at least one parameter, and it is to prompt for one par-
     ameter if it is not present.  The specification ensures that "M "
     is matched by the single character alone,  and  ASSEMBLE  by  the
     characters AS ASS ASSE ASSEM thru ASSEMBLE.

     In ASSEMBLE / M the filename given would normally be a plain name
     eg MCRDIS which would result in(UIC=[12,10]) 
      
     	MAC MCRDIS=LB:[1,1]EXEMC/ML,[11,10]RSXMC/PA:1,SY:[12,10]MCRDIS
     
~
     In LIST or TYPE since the required number of arguments is set  to
     one,  and  the  number of arguments to be prompted for is one the
     results are
      
     TY file		-> PIP TI:=file.MAC
     T file.slp		-> PIP TI:=file.slp
     TYPE file,file2	-> PIP TI:=file.MAC,file2.MAC
     TYPE
     FILE?myfile	-> PIP TI:=myfile.MAC
      
     COMPARE MCRDIS
     Output? TI:	-> CMP TI:.SLP/SL=MCRDIS;-1,MCRDIS
     CO
     Files? INDROT
     Output? INDROT	-> CMP INDROT.SLP/SL=INDROT;-1,INDROT
      
     or alternatively with the definition
      
     	$2722COMPARE
     	?1Files
     	?2Output
     	*CMP %2%%1.SLP%/SL=%1;-1%,%;0%
~
      
     one then has
     MCR>COM
     Files? INDROT
     Output? 		-> CMP INDROT.SLP/SL=INDROT;-1,INDROT;0
     or
     MCR>COM
     Files?INDROT
     Output?TI:		-> CMP TI:INDROT.SLP/SL=INDROT;-1,INDROT;0
~
      
      however altering this to
      
     	$2712COMPARE
     	..........
      leads to
     MCR> COM INDROT	-> CMP INDROT.SLP/SL=INDROT;-1,INDROT;0
     MCR> COM INDROT TI:-> CMP TI:INDROT.SLP/SL=INDROT;-1,INDROT;0
     and
     MCR> COMPARE
     Files?INDROT
     Output?TI:		->       ditto
      
     Because the number of parameters to prompt for was set to 2 
     if the required of 1 was not present.
      
     EXAMPLE:
      
     1.  UIC		==>  SET /UIC
     2.  UIC  [G,M]	==>  SET /UIC=[G,M]
     3.  UIC =[G,M]	==>  SET /UIC=[G,M]
~
      
          The following entries in SYSCCL.CCL produce the above
      syntax.
      
     		$3300UIC
     		*SET /UIC %2=%1=%
      
       Case 1.	No parameters present so   SET /UIC sent out.
      
       Case 2.	Since only one parameter is present ([G,M} {Remember
     		the comma in a UIC is not a delimiter.}, %2=% evaluates
     		to a null and %1=% evaluates to  =[G,M].
      
       Case 3.	The = sign (UIC =[G,M]) acts as the first delimiter
     		which means parameter 1 is evaluated to a null and
     		parameter 2 is evaluated to be =[G,M].
~      
      
     EXAMPLE:
      
     DIRECTORY filespec		==>PIP filespec/BR
      
          The CCL entries to produce this command would be
      
     		$3900DIRECTORY
     		*PIP %1;*%/BR
      
       Case 1.	The command DIRECTORY would have parameter 1 as 
     		null so the MCR command would be  PIP /BR.
      
       Case 2.	The command DIR *.CMD would have appended a ;* 
     		since there is no ';' in the command line typed in.  
     		So the command is passed back to MCR would be  
     		PIP *.cmd;*/BR.
      
       Case 3.	The command DIR *.CMD;1  would have nothing appended 
     		since a ';' is found in the input commnad.  Hence, 
     		the command PIP *.CMD;1/BR  would be sent to MCR
     		by CCL.
3	PASSING

               PASSING COMMAND LINES VIA THE RUN COMMAND


     Running a task via the RUN filespec facility causes the system to
     RUN  the  task and remove it on exit.  In reality MCR decodes the
     RUN command and then  issues  an  INS  filespec/RUN=REM/TASK=TTn.
     The /RUN=REM switch specifies that the task is to be removed from
     the installed task list when it exits.  In a standard RSX11M sys-
     tem  there  is no way to pass the task an MCR command line unless
     it is installed as an external MCR command(...XYZ).

          To partially bypass this restriction, a new switch has  been
     added   to   INS (and   hence   the   RUN   command),   the  /CMD
     switch (parameter).  The syntax is
      
     		RUN filespec/CMD="XYZ txt"

     Where XYZ is the MCR name
      
     where 'txt' is an ASCII command string.  
~

          It should be pointed out that a normal MCR command line  may
     be  up  to 80 characters long.  The longest command line possible
     via the RUN command is 53 characters(if filespec is 9  characters
     long).  Adding a /TASK=TSKANM switch , or a /PRI=N switch further
     decreases the maximum length in a command by 12 and 7  characters
     respectively.   CCL  checks to see if an expanded command line is
     <80  characters  long.   If  not  it  issues  an  error  message.
     However, when used CCL is used with the RUN command, error check-
     ing is more difficult because of  the  implicit  /RUN=REM  switch
     which  is  automatically inserted into the command line by SYS as
     the command is passed on to INS to Install, Run, and  Remove  the
     task.   If  it is desired to have CCL do as much checking on com-
     mand line length as possible, prototype command lines  in  either
     USERCCL.CCL  or SYSCCL.CCL should avoid using the RUN command and
     should replace it with INS filspec/RUN=REM.


     EXAMPLE:
      
     	RUN LB:[1,53]DMP/TASK=...DMP/CMD="DMP TI:=3831.ARC/AS"
        or
     	INS LB:[1,53]DMP/TASK=...DMP/RUN=REM/CMD="DMP TI:=3831.ARC/AS"
      
~
          If command lines are not expected to be long and the task is
     frequently  used  by a large number of users, the CCL command can
     RUN (INS /RUN=REM) the task with a taskname of the  form  ...XYZ.
     This  means  when  the next user goes to use the task, and if the
     first user is still using the task, multiple copies of  the  task
     will  be  created, one for each terminal using the task.  As each
     task exits it will be removed from the installed task list.  This
     cuts  down  somewhat  on  the overhead of looking through the CCL
     command files.  A simple example of this is BASIC on our  system.
     BASIC  is not normally an instaled task, rather when a user types
     BASIC, CCL runs BASIC and installes  it  with  the  name  ...BAS.
     Once  the origional copy of ...BAS is active, multiple copies can
     be created at various terminals.  For tasks  which  require  long
     command  lines(BASIC  requires none), this method is not suitable
     and it may be necessary  to  RUN  the  task  without  the  /TASK=
     switch.   This  means  that the task will be run with the name of
     the terminal(TTN).  

2	IDENT

	For CCL Version 8.0 and after, the version number of CCL
     can be obtainted by typing IDENT. IDENT is a command contained
     within the CCL internal file.
